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

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.

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 ():

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 X–y 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:

Les points verts représentent le X–y 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.

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

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

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

>>> 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

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.