Dans cet article, nous verrons comment diviser un ensemble de données à l'aide de train_test_split() de scikit-learns.
Fonction sklearn.model_selection.train_test_split() :
La méthode train_test_split() est utilisée pour diviser nos données en ensembles d'entraînement et de test. Tout d’abord, nous devons diviser nos données en fonctionnalités (X) et étiquettes (y). La trame de données est divisée en X_train, X_test, y_train et y_test. Les ensembles X_train et y_train sont utilisés pour la formation et l'ajustement du modèle. Les ensembles X_test et y_test sont utilisés pour tester le modèle s'il prédit les bonnes sorties/étiquettes. nous pouvons tester explicitement la taille du train et tester les ensembles. Il est suggéré de conserver nos rames plus grandes que les rames de test.
- Ensemble d'entraînement : l'ensemble de données de formation est un ensemble de données qui a été utilisé pour ajuster le modèle. L'ensemble de données sur lequel le modèle est formé. Ces données sont vues et apprises par le modèle. Ensemble de test : l'ensemble de données de test est un sous-ensemble de l'ensemble de données de formation qui est utilisé pour donner une évaluation précise de l'ajustement final du modèle. Ensemble de validation : un ensemble de données de validation est un échantillon de données de l'ensemble d'entraînement de votre modèle qui est utilisé pour estimer les performances du modèle tout en ajustant les hyperparamètres du modèle. sous-ajustement : un modèle de données sous-ajusté présente un taux d'erreur élevé à la fois sur l'ensemble d'apprentissage et sur les données non observées, car il est incapable de représenter efficacement la relation entre les variables d'entrée et de sortie. surajustement : lorsqu'un modèle statistique correspond exactement à ses données d'entraînement mais que l'objectif de l'algorithme est perdu car il est incapable de s'exécuter avec précision sur des données invisibles, on parle de surajustement
Syntaxe: sklearn.model_selection.train_test_split(*arrays, test_size=Aucun, train_size=Aucun, random_state=Aucun, shuffle=True, stratify=Aucun
Paramètres:
*tableaux : séquence d'indexables. Les listes, les tableaux numpy, les matrices scipy-sparse et les dataframes pandas sont tous des entrées valides. test_size : int ou float, par défaut Aucun. S'il est flottant, il doit être compris entre 0,0 et 1,0 et représenter le pourcentage de l'ensemble de données à tester. Si int est utilisé, il fait référence au nombre total d’échantillons testés. Si la valeur est Aucun, le complément de la taille du train est utilisé. Il sera défini sur 0,25 si la taille du train est également Aucune. train_size : int ou float, par défaut Aucun. random_state : int, par défaut Aucun. Contrôle la manière dont les données sont mélangées avant la mise en œuvre de la division. Pour une sortie reproductible sur plusieurs appels de fonction, transmettez un int. shuffle : objet booléen, par défaut True. Indique si les données doivent être mélangées ou non avant de les diviser. Stratify doit avoir la valeur None si shuffle=False. stratify : objet de type tableau, par défaut c'est None . Si Aucun est sélectionné, les données sont stratifiées en les utilisant comme étiquettes de classe.
Retour:
scission: La répartition des entrées lors du test d’entraînement est représentée sous forme de liste.
Étapes pour diviser l'ensemble de données :
Étape 1 : Importez les packages ou modules nécessaires :
Dans cette étape, nous importons les packages ou modules nécessaires dans l'environnement de travail Python.
Python3
# import packages> import> numpy as np> import> pandas as pd> from> sklearn.model_selection>import> train_test_split> |
>
>
Étape 2 : Importez la trame de données/l'ensemble de données :
Ici, nous chargeons le CSV à l'aide de la méthode pd.read_csv() de pandas et obtenons la forme de l'ensemble de données à l'aide de la fonction shape().
CSV utilisé :
Python3
alphabet avec des chiffres
# importing data> df>=> pd.read_csv(>'prediction.csv'>)> print>(df.shape)> |
>
>
Sortir:
(13, 3)>
Étape 3 : Obtenez les variables de fonctionnalités X et Y :
Ici, nous attribuons les variables X et Y dans lesquelles la variable de fonctionnalité X a des variables indépendantes et la variable de fonctionnalité y a une variable dépendante.
Python3
X>=> df[>'area'>]> y>=>df[>'prices'>]> |
>
>
Étape 4 : Utilisez la classe fractionnée de test de train pour diviser les données en ensembles de train et de test :
Ici, la classe train_test_split() de sklearn.model_selection est utilisée pour diviser nos données en ensembles d'entraînement et de test où les variables de caractéristiques sont données en entrée dans la méthode. test_size détermine la partie des données qui ira dans les ensembles de test et un état aléatoire est utilisé pour la reproductibilité des données.
renommer le dossier Linux
Python3
# using the train test split function> X_train, X_test, y_train, y_test>=> train_test_split(> >X,y , random_state>=>104>,test_size>=>0.25>, shuffle>=>True>)> |
commentaire javascript
>
>
Exemple:
Dans cet exemple, le fichier « predictions.csv » est importé. L'attribut df.shape est utilisé pour récupérer la forme du bloc de données. La forme de la trame de données est (13,3). Les colonnes de fonctionnalités sont prises dans la variable X et la colonne de résultat est prise dans la variable y. Les variables X et y sont transmises dans la méthode train_test_split() pour diviser la trame de données en ensembles d'entraînement et de test. Le paramètre d'état aléatoire est utilisé pour la reproductibilité des données. test_size est donné à 0,25, ce qui signifie que 25 % des données sont envoyées aux ensembles de test. 4 lignes sur 13 dans la trame de données vont dans les ensembles de test. 75 % des données vont dans les rames, soit 9 lignes sur 13. Les rames sont utilisées pour adapter et entraîner le modèle d’apprentissage automatique. Les ensembles de tests sont utilisés pour l’évaluation.
CSV utilisé :
Python3
# import packages> import> numpy as np> import> pandas as pd> from> sklearn.model_selection>import> train_test_split> # importing data> df>=> pd.read_csv(>'prediction.csv'>)> print>(df.shape)> # head of the data> print>(>'Head of the dataframe : '>)> print>(df.head())> print>(df.columns)> X>=> df[>'area'>]> y>=>df[>'prices'>]> # using the train test split function> X_train, X_test, y_train, y_test>=> train_test_split(> >X,y , random_state>=>104>,test_size>=>0.25>, shuffle>=>True>)> # printing out train and test sets> print>(>'X_train : '>)> print>(X_train.head())> print>(X_train.shape)> print>('')> print>(>'X_test : '>)> print>(X_test.head())> print>(X_test.shape)> print>('')> print>(>'y_train : '>)> print>(y_train.head())> print>(y_train.shape)> print>('')> print>(>'y_test : '>)> print>(y_test.head())> print>(y_test.shape)> |
>
>
Sortir:
(13, 3) Head of the dataframe : Unnamed: 0 area prices 0 0 1000 316404.109589 1 1 1500 384297.945205 2 2 2300 492928.082192 3 3 3540 661304.794521 4 4 4120 740061.643836 Index(['Unnamed: 0', 'area', 'prices'], dtype='object') X_train : 3 3540 7 3460 4 4120 0 1000 8 4750 Name: area, dtype: int64 (9,) X_test : 12 7100 2 2300 11 8600 10 9000 Name: area, dtype: int64 (4,) y_train : 3 661304.794521 7 650441.780822 4 740061.643836 0 316404.109589 8 825607.876712 Name: prices, dtype: float64 (9,) y_test : 12 1.144709e+06 2 4.929281e+05 11 1.348390e+06 10 1.402705e+06 Name: prices, dtype: float64 (4,)>
Exemple:
Dans cet exemple les étapes suivantes sont exécutées :
- Les packages nécessaires sont importés.
- L'ensemble de données Advertising.csv est chargé et nettoyé, et les valeurs nulles sont supprimées.
- Les tableaux de fonctionnalités et de cibles sont créés (X andy).
- Les tableaux créés sont divisés en ensembles d'entraînement et de test. 30 % de l'ensemble de données va dans l'ensemble de test, ce qui signifie que 70 % des données sont un ensemble de trains.
- Un objet scaler standard est créé.
- X_train est intégré au scaler.
- X_train et X_test sont transformés à l'aide de la méthode transform().
- Un modèle de régression linéaire simple est créé
- Les rames s'intègrent dans le modèle.
- la méthode prédire() permet d'effectuer des prédictions sur l'ensemble X_test.
- La métrique mean_squared_error() est utilisée pour évaluer le modèle.
Pour afficher et télécharger le fichier CSV utilisé dans cet exemple, cliquez sur ici .
Python3
# import packages> import> pandas as pd> import> numpy as np> from> sklearn.model_selection>import> train_test_split> from> sklearn.preprocessing>import> StandardScaler> from> sklearn.linear_model>import> LinearRegression> from> sklearn.metrics>import> mean_squared_error> df>=> pd.read_csv(>'Advertising.csv'>)> # dropping rows which have null values> df.dropna(inplace>=>True>,axis>=>0>)> y>=> df[>'sales'>]> X>=> df.drop(>'sales'>,axis>=>1>)> # splitting the dataframe into train and test sets> X_train,X_test,y_train,y_test>=> train_test_split(> >X,y,test_size>=>0.3>,random_state>=>101>)> scaler>=> StandardScaler()> scaler.fit(X_train)> X_train>=> scaler.transform(X_train)> X_test>=> scaler.transform(X_test)> model>=> LinearRegression().fit(X_train,y_train)> y_pred>=> model.predict(X_test)> print>(y_pred)> print>(mean_squared_error(y_test,y_pred))> |
>
>
chaîne ti int
Sortir:
tableau([19.82000933, 14.23636718, 12.80417236, 7.75461569, 8.31672266,
15.4001915, 11.6590983, 15.22650923, 15.53524916, 19.46415132,
17.21364106, 16.69603229, 16.46449309, 10.15345178, 13.44695953,
24.71946196, 18.67190453, 15.85505154, 14.45450049, 9.91684409,
10.41647177, 4.61335238, 17.41531451, 17.31014955, 21.72288151,
5.87934089, 11.29101265, 17.88733657, 21.04225992, 12.32251227,
14.4099317, 15.05829814, 10.2105313, 7.28532072, 12.66133397,
23.25847491, 18.87101505, 4.55545854, 19.79603707, 9.21203026,
10.24668718, 8.96989469, 13.33515217, 20.69532628, 12.17013119,
21.69572633, 16.7346457, 22.16358256, 5.34163764, 20.43470231,
7.58252563, 23.38775769, 10.2270323, 12.33473902, 24.10480458,
9.88919804, 21.7781076 ])
2.7506859249500466
Exemple:
Dans cet exemple, nous allons utiliser le modèle de classificateur des K-voisins les plus proches.
Dans cet exemple les étapes suivantes sont exécutées :
- Les packages nécessaires sont importés.
- Les données de l'iris sont chargées à partir de sklearn.datasets.
- Les tableaux de fonctionnalités et de cibles sont créés (X andy).
- Les tableaux créés sont divisés en ensembles d'entraînement et de test. 30 % de l'ensemble de données va dans l'ensemble de test, ce qui signifie que 70 % des données sont un ensemble de trains.
- Un modèle Knn de base est créé à l'aide de la classe KNeighborsClassifier.
- Les rames s'intègrent dans le modèle knn.
- la méthode prédire() permet d'effectuer des prédictions sur l'ensemble X_test.
Python3
commandes ls Linux
# Import packages> from> sklearn.neighbors>import> KNeighborsClassifier> from> sklearn.model_selection>import> train_test_split> from> sklearn.datasets>import> load_iris> > # Load the data> irisData>=> load_iris()> > # Create feature and target arrays> X>=> irisData.data> y>=> irisData.target> > # Split data into train and test sets> X_train, X_test, y_train, y_test>=> train_test_split(> >X, y, test_size>=> 0.2>, random_state>=>42>)> > knn>=> KNeighborsClassifier(n_neighbors>=>1>)> > knn.fit(X_train, y_train)> > # predicting on the X_test data set> print>(knn.predict(X_test))> |
>
>
Sortir:
[1 0 2 1 1 0 1 2 1 1 2 0 0 0 0 1 2 1 1 2 0 2 0 2 2 2 2 2 0 0]