In questo articolo, discuteremo come dividere un set di dati utilizzando train_test_split() di scikit-learns.
Funzione sklearn.model_selection.train_test_split():
Il metodo train_test_split() viene utilizzato per dividere i nostri dati in set di train e test. Innanzitutto, dobbiamo dividere i nostri dati in caratteristiche (X) ed etichette (y). Il dataframe viene diviso in X_train, X_test, y_train e y_test. I set X_train e y_train vengono utilizzati per l'addestramento e l'adattamento del modello. I set X_test e y_test vengono utilizzati per testare il modello se prevede gli output/etichette corretti. possiamo testare esplicitamente la dimensione del treno e dei set di test. Si suggerisce di mantenere i nostri convogli più grandi dei set di prova.
- Set di treni: il set di dati di addestramento è un set di dati utilizzato per adattarsi al modello. Il set di dati su cui viene addestrato il modello. Questi dati vengono visti e appresi dal modello. Set di test: il set di dati di test è un sottoinsieme del set di dati di training utilizzato per fornire una valutazione accurata dell'adattamento del modello finale. set di convalida: un set di dati di convalida è un campione di dati dal set di training del modello che viene utilizzato per stimare le prestazioni del modello durante l'ottimizzazione degli iperparametri del modello. sottoadattamento: un modello di dati sottoadattato ha un tasso di errore elevato sia sul set di addestramento che sui dati non osservati perché non è in grado di rappresentare efficacemente la relazione tra le variabili di input e di output. overfitting: quando un modello statistico corrisponde esattamente ai suoi dati di addestramento ma l'obiettivo dell'algoritmo viene perso perché non è in grado di eseguire con precisione dati invisibili si chiama overfitting
Sintassi: sklearn.model_selection.train_test_split(*arrays, test_size=None, train_size=None, random_state=None, shuffle=True, stratify=None
parametri:
*array: sequenza di indicizzabili. Elenchi, array numpy, matrici scipy-sparse e dataframe panda sono tutti input validi. test_size: int o float, per impostazione predefinita Nessuno. Se float, dovrebbe essere compreso tra 0,0 e 1,0 e rappresentare la percentuale del set di dati da testare suddiviso. Se viene utilizzato int, si riferisce al numero totale di campioni di prova. Se il valore è Nessuno, viene utilizzato il complemento della dimensione del treno. Verrà impostato su 0,25 se anche la dimensione del treno è Nessuna. train_size: int o float, per impostazione predefinita Nessuno. random_state: int, per impostazione predefinita Nessuno. Controlla il modo in cui i dati vengono mescolati prima che venga implementata la suddivisione. Per un output ripetibile tra diverse chiamate di funzione, passare un int. shuffle: oggetto booleano, per impostazione predefinita True. Indica se i dati devono essere mescolati o meno prima della suddivisione. La stratificazione deve essere Nessuna se shuffle=False. stratify: oggetto simile ad un array, per impostazione predefinita è None . Se si seleziona Nessuno, i dati vengono stratificati utilizzando questi come etichette di classe.
Ritorna:
scissione: La suddivisione degli input del test di treno è rappresentata come un elenco.
Passaggi per dividere il set di dati:
Passaggio 1: importa i pacchetti o i moduli necessari:
In questo passaggio, stiamo importando i pacchetti o i moduli necessari nell'ambiente Python funzionante.
Python3
# import packages> import> numpy as np> import> pandas as pd> from> sklearn.model_selection> import> train_test_split> |
>
>
Passaggio 2: importa il frame di dati/il set di dati:
Qui carichiamo il CSV utilizzando il metodo pd.read_csv() di Pandas e otteniamo la forma del set di dati utilizzando la funzione shape().
CSV utilizzato:

Python3
# importing data> df> => pd.read_csv(> 'prediction.csv'> )> print> (df.shape)> |
>
>
Produzione:
(13, 3)>
Passaggio 3: ottenere le variabili della funzione X e Y:
Qui stiamo assegnando la variabile X e Y in cui la variabile della caratteristica X ha variabili indipendenti e la variabile della caratteristica y ha una variabile dipendente.
Python3
X> => df[> 'area'> ]> y> => df[> 'prices'> ]> |
>
>
Passaggio 4: utilizzare la classe di suddivisione del test del treno per suddividere i dati in set di treno e test:
Qui, la classe train_test_split() di sklearn.model_selection viene utilizzata per dividere i nostri dati in set di training e test in cui le variabili delle funzionalità vengono fornite come input nel metodo. test_size determina la porzione di dati che verrà inserita nei set di test e per la riproducibilità dei dati viene utilizzato uno stato casuale.
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> )> |
>
>
Esempio:
In questo esempio viene importato il file 'predictions.csv'. L'attributo df.shape viene utilizzato per recuperare la forma del frame di dati. La forma del dataframe è (13,3). Le colonne delle caratteristiche sono prese nella variabile X e la colonna dei risultati è presa nella variabile y. Le variabili X e y vengono passate nel metodo train_test_split() per dividere il frame di dati in set di train e test. Il parametro di stato casuale viene utilizzato per la riproducibilità dei dati. test_size è indicato come 0,25, il che significa che il 25% dei dati viene inserito nei set di test. 4 righe su 13 nel dataframe vanno nei set di test. Il 75% dei dati va nei convogli, ovvero 9 righe su 13 righe. I set di treni vengono utilizzati per adattare e addestrare il modello di machine learning. I set di test vengono utilizzati per la valutazione.
CSV utilizzato:

Python3
java int nella stringa
# 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)> |
>
>
Produzione:
(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,)>
Esempio:
In questo esempio vengono eseguiti i seguenti passaggi:
- I pacchetti necessari vengono importati.
- Il set di dati Advertising.csv viene caricato e pulito e i valori null vengono eliminati.
- vengono creati gli array di funzionalità e target (X andy).
- Gli array creati vengono suddivisi in set di training e set di test. Il 30% del set di dati viene inserito nel set di test, il che significa che il 70% dei dati è un set di treni.
- Viene creato un oggetto scaler standard.
- X_train è inserito nello scaler.
- X_train e X_test vengono trasformati utilizzando il metodo trasforma().
- Viene creato un semplice modello di regressione lineare
- I trenini si adattano al modello.
- il metodo predic() viene utilizzato per effettuare previsioni sul set X_test.
- la metrica mean_squared_error() viene utilizzata per valutare il modello.
Per visualizzare e scaricare il file CSV utilizzato in questo esempio, fare clic su Qui .
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))> |
>
>
Produzione:
matrice([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
Esempio:
In questo esempio, utilizzeremo il modello di classificazione dei vicini K-più vicini.
In questo esempio vengono eseguiti i seguenti passaggi:
- I pacchetti necessari vengono importati.
- I dati dell'iride vengono caricati da sklearn.datasets.
- vengono creati gli array di funzionalità e target (X andy).
- Gli array creati vengono suddivisi in set di training e set di test. Il 30% del set di dati viene inserito nel set di test, il che significa che il 70% dei dati è un set di treni.
- Un modello Knn di base viene creato utilizzando la classe KNeighborsClassifier.
- I trenini si adattano al modello knn.
- il metodo predic() viene utilizzato per effettuare previsioni sul set X_test.
Python3
# 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))> |
>
>
Produzione:
[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]