Divisez votre ensemble de données avec le train_test_split () de scikit-learn – Real Python

By | novembre 23, 2020

Formation gratuite Python

L'un des aspects clés de l'apprentissage automatique supervisé est l'évaluation et la validation des modèles. Lorsque vous évaluez les performances prédictives de votre modèle, il est essentiel que le processus soit impartial. En utilisant train_test_split () à partir de la bibliothèque de science des données scikit-learn, vous pouvez diviser votre ensemble de données en sous-ensembles qui minimisent le potentiel de biais dans votre processus d'évaluation et de validation.

L'importance du fractionnement des données

L'apprentissage automatique supervisé consiste à créer des modèles qui mappent précisément les entrées données (variables indépendantes ou prédicteurs) aux sorties données (variables dépendantes, ou réponses).

La façon dont vous mesurez la précision de votre modèle dépend du type de problème que vous essayez de résoudre. Dans l'analyse de régression, vous utilisez généralement le coefficient de détermination, l'erreur quadratique moyenne, l'erreur absolue moyenne ou des quantités similaires. Pour les problèmes de classification, vous appliquez souvent l'exactitude, la précision, le rappel, le score F1 et les indicateurs associés.

Les valeurs numériques acceptables qui mesurent la précision varient d'un champ à l'autre. Vous pouvez trouver des explications détaillées dans Statistics By Jim, Quora et de nombreuses autres ressources.

Le plus important à comprendre est que vous avez généralement besoin évaluation impartiale pour utiliser correctement ces mesures, évaluer les performances prédictives de votre modèle et valider le modèle.

Cela signifie que vous ne pouvez pas évaluer les performances prédictives d'un modèle avec les mêmes données que vous avez utilisées pour l'entraînement. Vous devez évaluer le modèle avec données fraîches qui n’a jamais été vue par le modèle auparavant. Vous pouvez accomplir cela en divisant votre ensemble de données avant de l'utiliser.

Ensembles de formation, de validation et de test

La division de votre ensemble de données est essentielle pour une évaluation impartiale des performances de prédiction. Dans la plupart des cas, il suffit de diviser votre ensemble de données de manière aléatoire en trois sous-ensembles:

  1. L'ensemble d'entraînement est appliqué pour former, ou en forme, votre modèle. Par exemple, vous utilisez l'ensemble d'apprentissage pour trouver les poids optimaux, ou coefficients, pour la régression linéaire, la régression logistique ou les réseaux de neurones.

  2. L'ensemble de validation est utilisé pour l'évaluation non biaisée du modèle pendant le réglage des hyperparamètres. Par exemple, lorsque vous souhaitez trouver le nombre optimal de neurones dans un réseau de neurones ou le meilleur noyau pour une machine à vecteurs de support, vous expérimentez avec différentes valeurs. Pour chaque paramètre d'hyperparamètres considéré, vous ajustez le modèle à l'ensemble d'apprentissage et évaluez ses performances avec l'ensemble de validation.

  3. L'ensemble de test est nécessaire pour une évaluation impartiale du modèle final. Vous ne devez pas l'utiliser pour l'ajustement ou la validation.

Dans les cas moins complexes, lorsque vous n’avez pas besoin de régler des hyperparamètres, vous pouvez travailler uniquement avec les ensembles d’entraînement et de test.

Sous-ajustement et sur-ajustement

La division d'un ensemble de données peut également être importante pour détecter si votre modèle souffre de l'un des deux problèmes très courants, appelés sous-ajustement et sur-ajustement:

  1. Sous-ajustement est généralement la conséquence d'un modèle incapable d'encapsuler les relations entre les données. Par exemple, cela peut se produire lorsque vous essayez de représenter des relations non linéaires avec un modèle linéaire. Les modèles sous-équipés auront probablement de mauvaises performances avec les ensembles d'entraînement et de test.

  2. Surapprentissage se produit généralement lorsqu'un modèle a une structure excessivement complexe et apprend à la fois les relations existantes entre les données et le bruit. Ces modèles ont souvent de mauvaises capacités de généralisation. Bien qu'ils fonctionnent bien avec les données d'entraînement, ils produisent généralement de mauvaises performances avec des données (de test) invisibles.

Vous pouvez trouver une explication plus détaillée du sous-ajustement et du sur-ajustement dans la régression linéaire en Python.

Conditions préalables à l'utilisation train_test_split ()

Maintenant que vous comprenez la nécessité de fractionner un ensemble de données afin d'effectuer une évaluation impartiale du modèle et d'identifier le sous-ajustement ou le surajustement, vous êtes prêt à apprendre à fractionner vos propres ensembles de données.

Vous utiliserez la version 0.23.1 de scikit-learn, ou sklearn. Il propose de nombreux packages pour la science des données et l'apprentissage automatique, mais pour ce didacticiel, vous vous concentrerez sur les model_selection paquet, en particulier sur la fonction train_test_split ().

Vous pouvez installer sklearn avec installation de pip:

$ python -m pip install -U "scikit-learn == 0.23.1"

Si vous utilisez Anaconda, vous l'avez probablement déjà installé. Cependant, si vous souhaitez utiliser un nouvel environnement, assurez-vous que vous disposez de la version spécifiée ou utilisez Miniconda, vous pouvez installer sklearn depuis Anaconda Cloud avec installation de conda:

$ conda installer -c anaconda scikit-learn=0.23

Vous aurez également besoin de NumPy, mais vous n'avez pas à l'installer séparément. Vous devriez vous entendre avec sklearn si vous ne l'avez pas déjà installé. Si vous souhaitez actualiser vos connaissances sur NumPy, consultez la documentation officielle ou consultez Look Ma, No For-Loops: Array Programming With NumPy.

Application de train_test_split ()

Vous devez importer train_test_split () et NumPy avant de pouvoir les utiliser, vous pouvez donc commencer avec le importer déclarations:

>>>

>>> importer engourdi comme np
>>> de sklearn.model_selection importer train_test_split

Maintenant que vous avez les deux importés, vous pouvez les utiliser pour diviser les données en ensembles d'apprentissage et ensembles de test. Vous diviserez les entrées et les sorties en même temps, avec un seul appel de fonction.

Avec train_test_split (), vous devez fournir les séquences que vous souhaitez fractionner ainsi que tous les arguments facultatifs. Il renvoie une liste de tableaux NumPy, d'autres séquences ou de matrices SciPy clairsemées, le cas échéant:

sklearn.model_selection.train_test_split(*tableaux, **options) -> liste

tableaux est la séquence de listes, de tableaux NumPy, de pandas DataFrames ou d'objets similaires de type tableau contenant les données que vous souhaitez fractionner. Tous ces objets forment ensemble le jeu de données et doivent être de la même longueur.

Dans les applications de machine learning supervisées, vous travaillez généralement avec deux de ces séquences:

  1. Un tableau à deux dimensions avec les entrées (X)
  2. Un tableau unidimensionnel avec les sorties (y)

options sont les arguments de mots clés facultatifs que vous pouvez utiliser pour obtenir le comportement souhaité:

  • train_size est le nombre qui définit la taille de l'ensemble d'apprentissage. Si vous fournissez un flotte, alors ça doit être entre 0,0 et 1.0 et définira la part de l'ensemble de données utilisée pour les tests. Si vous fournissez un int, puis il représentera le nombre total d'échantillons d'apprentissage. La valeur par défaut est Aucun.

  • test_size est le nombre qui définit la taille de l'ensemble de test. C'est très similaire à train_size. Vous devez fournir soit train_size ou test_size. Si ni l'un ni l'autre n'est indiqué, le partage par défaut de l'ensemble de données qui sera utilisé pour les tests est 0,25, soit 25 pour cent.

  • random_state est l'objet qui contrôle la randomisation lors du fractionnement. Cela peut être soit un int ou une instance de RandomState. La valeur par défaut est Aucun.

  • mélanger est l'objet booléen (Vrai par défaut) qui détermine s'il faut mélanger l'ensemble de données avant d'appliquer le fractionnement.

  • stratifier est un objet de type tableau qui, sinon Aucun, détermine comment utiliser une division stratifiée.

Il est maintenant temps d’essayer le fractionnement des données! Vous allez commencer par créer un ensemble de données simple avec lequel travailler. L'ensemble de données contiendra les entrées dans le tableau à deux dimensions X et sorties dans le tableau unidimensionnel y:

>>>

>>> X = np.organiser(1, 25).remodeler(12, 2)
>>> y = np.tableau([[[[0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> X
tableau ([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
tableau ([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])

Pour obtenir vos données, vous utilisez arange (), ce qui est très pratique pour générer des tableaux basés sur des plages numériques. Vous utilisez également .reshape () pour modifier la forme du tableau renvoyé par arange () et obtenez une structure de données bidimensionnelle.

Vous pouvez diviser les ensembles de données d'entrée et de sortie avec un seul appel de fonction:

>>>

>>> x_train, x_test, y_train, y_test = train_test_split(X, y)
>>> x_train
tableau ([[[[[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
tableau ([[[[[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
tableau ([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
tableau ([1, 0, 0])

Étant donné deux séquences, comme X et y ici, train_test_split () effectue le fractionnement et renvoie quatre séquences (dans ce cas des tableaux NumPy) dans cet ordre:

  1. x_train: La partie formation de la première séquence (X)
  2. x_test: La partie test de la première séquence (X)
  3. y_train: La partie formation de la deuxième séquence (y)
  4. y_test: La partie test de la deuxième séquence (y)

Vous avez probablement des résultats différents de ce que vous voyez ici. En effet, le fractionnement de l'ensemble de données est aléatoire par défaut. Le résultat diffère à chaque fois que vous exécutez la fonction. Cependant, ce n’est souvent pas ce que vous voulez.

Parfois, pour rendre vos tests reproductibles, vous avez besoin d'une division aléatoire avec la même sortie pour chaque appel de fonction. Vous pouvez le faire avec le paramètre random_state. La valeur de random_state n'est pas important – il peut s'agir de n'importe quel entier non négatif. Vous pouvez utiliser une instance de numpy.random.RandomState au lieu de cela, mais c'est une approche plus complexe.

Dans l'exemple précédent, vous avez utilisé un ensemble de données avec douze observations (lignes) et obtenu un échantillon d'apprentissage avec neuf lignes et un échantillon test avec trois lignes. C'est parce que vous n'avez pas spécifié la taille souhaitée des ensembles d'entraînement et de test. Par défaut, 25% des échantillons sont affectés à l'ensemble de test. Ce rapport convient généralement à de nombreuses applications, mais ce n’est pas toujours ce dont vous avez besoin.

En règle générale, vous souhaiterez définir explicitement la taille de l'ensemble de tests (ou d'entraînement), et parfois vous souhaiterez même expérimenter différentes valeurs. Vous pouvez le faire avec les paramètres train_size ou test_size.

Modifiez le code pour pouvoir choisir la taille de l'ensemble de test et obtenir un résultat reproductible:

>>>

>>> x_train, x_test, y_train, y_test = train_test_split(
...     X, y, test_size=4, random_state=4
... )
>>> x_train
tableau ([[[[[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
tableau ([[[[[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
tableau ([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
tableau ([0, 1, 0, 0])

Avec ce changement, vous obtenez un résultat différent d'avant. Auparavant, vous aviez un ensemble d'entraînement avec neuf éléments et un ensemble de test avec trois éléments. Maintenant, grâce à l'argument test_size = 4, l'ensemble de formation comporte huit éléments et l'ensemble de test en comporte quatre. Vous obtiendrez le même résultat avec test_size = 0,33 parce que 33 pour cent de douze sont environ quatre.

Il y a une autre différence très importante entre les deux derniers exemples: vous obtenez désormais le même résultat à chaque fois que vous exécutez la fonction. En effet, vous avez corrigé le générateur de nombres aléatoires avec random_state = 4.

La figure ci-dessous montre ce qui se passe lorsque vous appelez train_test_split ():

mmst-train-test-split-1

Les échantillons de l'ensemble de données sont mélangés au hasard, puis divisés en ensembles d'apprentissage et de test en fonction de la taille que vous avez définie.

Tu peux voir ça y a six zéros et six uns. Cependant, l'ensemble de test a trois zéros sur quatre éléments. Si vous souhaitez (approximativement) conserver la proportion de y valeurs à travers les ensembles de formation et de test, puis passez stratifier = y. Cela permettra le fractionnement stratifié:

>>>

>>> x_train, x_test, y_train, y_test = train_test_split(
...     X, y, test_size=0,33, random_state=4, stratifier=y
... )
>>> x_train
tableau ([[[[[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
tableau ([[[[[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
tableau ([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
tableau ([0, 0, 1, 1])

Maintenant y_train et y_test ont le même rapport de zéros et de uns que l'original y tableau.

Les fractionnements stratifiés sont souhaitables dans certains cas, comme lorsque vous classez un jeu de données déséquilibré, un ensemble de données avec une différence significative dans le nombre d'échantillons appartenant à des classes distinctes.

Enfin, vous pouvez désactiver la lecture aléatoire des données et la répartition aléatoire avec shuffle = Faux:

>>>

>>> x_train, x_test, y_train, y_test = train_test_split(
...     X, y, test_size=0,33, mélanger=Faux
... )
>>> x_train
tableau ([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
tableau ([[[[[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
tableau ([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
tableau ([1, 0, 1, 0])

Vous avez maintenant une division dans laquelle les deux premiers tiers des échantillons de l'original X et y les tableaux sont affectés à l'ensemble d'apprentissage et le dernier tiers à l'ensemble de test. Pas de mélange. Pas de hasard.

Apprentissage automatique supervisé avec train_test_split ()

Il est maintenant temps de voir train_test_split () en action lors de la résolution de problèmes d'apprentissage supervisé. Vous commencerez par un petit problème de régression qui peut être résolu avec une régression linéaire avant d’examiner un problème plus important. Vous verrez également que vous pouvez utiliser train_test_split () pour la classification également.

Exemple minimaliste de régression linéaire

Dans cet exemple, vous allez appliquer ce que vous avez appris jusqu'à présent pour résoudre un petit problème de régression. Vous apprendrez à créer des ensembles de données, à les diviser en sous-ensembles d'entraînement et de test, et à les utiliser pour la régression linéaire.

Comme toujours, vous commencerez par importer les packages, fonctions ou classes nécessaires. Vous aurez besoin de NumPy, Régression linéaire, et train_test_split ():

>>>

>>> importer engourdi comme np
>>> de sklearn.linear_model importer Régression linéaire
>>> de sklearn.model_selection importer train_test_split

Maintenant que vous avez importé tout ce dont vous avez besoin, vous pouvez créer deux petits tableaux, X et y, pour représenter les observations, puis les diviser en ensembles d'entraînement et de test comme vous l'avez fait auparavant:

>>>

>>> X = np.organiser(20).remodeler(-1, 1)
>>> y = np.tableau([[[[5, 12, 11, 19, 30, 29, 23, 40, 51, 54, 74,
...               62, 68, 73, 89, 84, 89, 101, 99, 106])
>>> X
tableau ([[ 0],
       [ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10],
       [11],
       [12],
       [13],
       [14],
       [15],
       [16],
       [17],
       [18],
       [19]])
>>> y
tableau ([5121119302923405154746268[5121119302923405154746268[5121119302923405154746268[5121119302923405154746268
                                73, 89, 84, 89, 101, 99, 106])
>>> x_train, x_test, y_train, y_test = train_test_split(
...     X, y, test_size=8, random_state=0
... )

Votre ensemble de données contient vingt observations, ou Xy paires. Vous spécifiez l'argument test_size = 8, donc l'ensemble de données est divisé en un ensemble d'apprentissage avec douze observations et un ensemble de test avec huit observations.

Vous pouvez maintenant utiliser l'ensemble d'entraînement pour s'adapter au modèle:

>>>

>>> modèle = Régression linéaire().en forme(x_train, y_train)
>>> modèle.intercepter_
3,1617195496417523
>>> modèle.coef_
tableau ([5.53121801])

Régression linéaire crée l'objet qui représente le modèle, tandis que .en forme() entraîne ou ajuste le modèle et le renvoie. Avec la régression linéaire, ajuster le modèle signifie déterminer la meilleure intersection (model.intercept_) et pente (model.coef_) valeurs de la droite de régression.

Bien que vous puissiez utiliser x_train et y_train pour vérifier la qualité de l'ajustement, ce n'est pas une bonne pratique. Une estimation non biaisée des performances prédictives de votre modèle est basée sur des données de test:

>>>

>>> modèle.But(x_train, y_train)
0,9868175024574795
>>> modèle.But(x_test, y_test)
0,9465896927715023

.But() renvoie le coefficient de détermination, ou R², pour les données transmises. Son maximum est 1. Plus le R² valeur, meilleur est l'ajustement. Dans ce cas, les données d'entraînement donnent un coefficient légèrement plus élevé. Cependant, le R² calculé avec des données de test est une mesure impartiale des performances de prédiction de votre modèle.

Voici à quoi cela ressemble sur un graphique:

mmst-train-test-split-2

Les points verts représentent le Xy paires utilisées pour l'entraînement. La ligne noire, appelée ligne de régression estimée, est définie par les résultats de l'ajustement du modèle: l'intersection et la pente. Ainsi, il reflète uniquement les positions des points verts.

Les points blancs représentent l'ensemble de test. Vous les utilisez pour estimer les performances du modèle (ligne de régression) avec des données non utilisées pour l'apprentissage.

Exemple de régression

Vous êtes maintenant prêt à fractionner un plus grand ensemble de données pour résoudre un problème de régression. Vous utiliserez un ensemble de données bien connu sur les prix des logements à Boston, qui est inclus dans sklearn. Cet ensemble de données contient 506 échantillons, 13 variables d'entrée et les valeurs de la maison en sortie. Vous pouvez le récupérer avec load_boston ().

Tout d'abord, importez train_test_split () et load_boston ():

>>>

>>> de sklearn.datasets importer load_boston
>>> de sklearn.model_selection importer train_test_split

Maintenant que vous avez importé les deux fonctions, vous pouvez faire travailler les données:

>>>

>>> X, y = load_boston(return_X_y=Vrai)

Comme vous pouvez le voir, load_boston () avec l'argument return_X_y = Vrai renvoie un tuple avec deux tableaux NumPy:

  1. Un tableau bidimensionnel avec les entrées
  2. Un tableau unidimensionnel avec les sorties

L'étape suivante consiste à fractionner les données de la même manière qu'auparavant:

>>>

>>> x_train, x_test, y_train, y_test = train_test_split(
...     X, y, test_size=0,4, random_state=0
... )

Vous avez maintenant les ensembles de formation et de test. Les données d'entraînement sont contenues dans x_train et y_train, alors que les données pour les tests sont en x_test et y_test.

Lorsque vous travaillez avec des ensembles de données plus volumineux, il est généralement plus pratique de passer la taille de la formation ou du test sous forme de ratio. test_size = 0.4 signifie qu'environ 40% des échantillons seront affectés aux données de test, et les 60% restants seront affectés aux données de formation.

Enfin, vous pouvez utiliser l'ensemble d'entraînement (x_train et y_train) pour s'adapter au modèle et à l'ensemble de test (x_test et y_test) pour une évaluation non biaisée du modèle. Dans cet exemple, vous allez appliquer trois algorithmes de régression bien connus pour créer des modèles adaptés à vos données:

  1. Régression linéaire avec Régression linéaire()
  2. Augmentation du dégradé avec DégradéBoostingRegressor ()
  3. Forêt aléatoire avec RandomForestRegressor ()

Le processus est à peu près le même que dans l'exemple précédent:

  1. Importer les cours dont vous avez besoin.
  2. Créer instances de modèle utilisant ces classes.
  3. En forme les instances de modèle avec .en forme() en utilisant le kit d'entraînement.
  4. Évaluer le modèle avec .But() en utilisant l'ensemble de test.

Voici le code qui suit les étapes décrites ci-dessus pour les trois algorithmes de régression:

>>>

>>> de sklearn.linear_model importer Régression linéaire
>>> modèle = Régression linéaire().en forme(x_train, y_train)
>>> modèle.But(x_train, y_train)
0,7668160223286261
>>> modèle.But(x_test, y_test)
0,6882607142538016

>>> de sklearn.ensemble importer DégradéBoostingRegressor
>>> modèle = DégradéBoostingRegressor(random_state=0).en forme(x_train, y_train)
>>> modèle.But(x_train, y_train)
0,9859065238883613
>>> modèle.But(x_test, y_test)
0,8530127436482149

>>> de sklearn.ensemble importer RandomForestRegressor
>>> modèle = RandomForestRegressor(random_state=0).en forme(x_train, y_train)
>>> modèle.But(x_train, y_train)
0,9811695664860354
>>> modèle.But(x_test, y_test)
0,8325867908704008

Vous avez utilisé vos ensembles de données d'entraînement et de test pour adapter trois modèles et évaluer leurs performances. La mesure de la précision obtenue avec .But() est le coefficient de détermination. Il peut être calculé avec l'ensemble de formation ou de test. Cependant, comme vous l'avez déjà appris, le score obtenu avec l'ensemble de tests représente une estimation non biaisée des performances.

Comme mentionné dans la documentation, vous pouvez fournir des arguments facultatifs à Régression linéaire(), DégradéBoostingRegressor (), et RandomForestRegressor (). DégradéBoostingRegressor () et RandomForestRegressor () Utilisez le random_state paramètre pour la même raison que train_test_split () fait: gérer l'aléatoire dans les algorithmes et assurer la reproductibilité.

Pour certaines méthodes, vous pouvez également avoir besoin d'une mise à l'échelle des fonctionnalités. Dans de tels cas, vous devez adapter les scalers aux données d'entraînement et les utiliser pour transformer les données de test.

Exemple de classification

Vous pouvez utiliser train_test_split () résoudre classification problèmes de la même manière que vous le faites pour l'analyse de régression. Dans l'apprentissage automatique, les problèmes de classification impliquent la formation d'un modèle pour appliquer des étiquettes aux valeurs d'entrée ou les classer et trier votre ensemble de données en catégories.

Dans le didacticiel Régression logistique en Python, vous trouverez un exemple de tâche de reconnaissance d'écriture manuscrite. L'exemple fournit une autre démonstration de la division des données en ensembles de formation et de test pour éviter les biais dans le processus d'évaluation.

Autres fonctionnalités de validation

Le paquet sklearn.model_selection offre de nombreuses fonctionnalités liées à la sélection et à la validation des modèles, dont les suivantes:

  • Validation croisée
  • Courbes d'apprentissage
  • Réglage des hyperparamètres

La validation croisée est un ensemble de techniques qui combinent les mesures des performances de prédiction pour obtenir des estimations de modèle plus précises.

L'une des méthodes de validation croisée largement utilisées est k-fold validation croisée. Dans celui-ci, vous divisez votre ensemble de données en k (souvent cinq ou dix) sous-ensembles, ou plis, de taille égale, puis exécutez les procédures de formation et de test k fois. Chaque fois, vous utilisez un pli différent comme ensemble de test et tous les plis restants comme ensemble d'entraînement. Cela fournit k mesures des performances prédictives, et vous pouvez ensuite analyser leur moyenne et leur écart type.

Vous pouvez implémenter la validation croisée avec KFold, StratifiéKFold, LeaveOneOut, et quelques autres classes et fonctions de sklearn.model_selection.

Une courbe d'apprentissage, parfois appelée courbe d'apprentissage, montre comment le score de prédiction des ensembles d'entraînement et de validation dépend du nombre d'échantillons d'apprentissage. Vous pouvez utiliser courbe d'apprentissage() pour obtenir cette dépendance, qui peut vous aider à trouver la taille optimale de l'ensemble d'entraînement, à choisir des hyperparamètres, à comparer des modèles, etc.

Le réglage des hyperparamètres, également appelé optimisation des hyperparamètres, consiste à déterminer le meilleur ensemble d'hyperparamètres pour définir votre modèle d'apprentissage automatique. sklearn.model_selection vous propose plusieurs options à cet effet, notamment GridSearchCV, RandomizedSearchCV, validation_curve (), et d'autres. Le fractionnement de vos données est également important pour le réglage des hyperparamètres.

Conclusion

Vous savez maintenant pourquoi et comment utiliser train_test_split () de sklearn. Vous avez appris que, pour une estimation impartiale des performances prédictives des modèles d'apprentissage automatique, vous devez utiliser des données qui n'ont pas été utilisées pour l'ajustement du modèle. C'est pourquoi vous devez diviser votre ensemble de données en sous-ensembles d'entraînement, de test et, dans certains cas, de validation.

Dans ce didacticiel, vous avez appris à:

  • Utilisation train_test_split () pour obtenir des ensembles de formation et de test
  • Contrôlez la taille des sous-ensembles avec les paramètres train_size et test_size
  • Détermine le hasard de vos divisions avec le random_state paramètre
  • Obtenir scissions stratifiées avec le stratifier paramètre
  • Utilisation train_test_split () faisant partie de apprentissage automatique supervisé procédures

Vous avez également vu que le sklearn.model_selection Le module propose plusieurs autres outils de validation de modèle, y compris la validation croisée, les courbes d'apprentissage et le réglage des hyperparamètres.

Si vous avez des questions ou des commentaires, veuillez les mettre dans la section commentaires ci-dessous.