En este artículo, discutiremos cómo dividir un conjunto de datos utilizando train_test_split() de scikit-learns.
función sklearn.model_selection.train_test_split():
El método train_test_split() se usa para dividir nuestros datos en conjuntos de entrenamiento y prueba. Primero, necesitamos dividir nuestros datos en características (X) y etiquetas (y). El marco de datos se divide en X_train, X_test, y_train y y_test. Los conjuntos X_train e y_train se utilizan para entrenar y ajustar el modelo. Los conjuntos X_test e y_test se usan para probar el modelo si está prediciendo los resultados/etiquetas correctos. podemos probar explícitamente el tamaño del tren y los conjuntos de prueba. Se sugiere mantener nuestros conjuntos de trenes más grandes que los conjuntos de prueba.
- Conjunto de entrenamiento: el conjunto de datos de entrenamiento es un conjunto de datos que se utilizó para ajustar el modelo. El conjunto de datos en el que se entrena el modelo. Estos datos son vistos y aprendidos por el modelo.
- Conjunto de prueba: el conjunto de datos de prueba es un subconjunto del conjunto de datos de entrenamiento que se utiliza para brindar una evaluación precisa del ajuste del modelo final.
- conjunto de validación: un conjunto de datos de validación es una muestra de datos del conjunto de entrenamiento de su modelo que se usa para estimar el rendimiento del modelo mientras ajusta los hiperparámetros del modelo.
- ajuste insuficiente: un modelo de datos que está ajustado de manera insuficiente tiene una alta tasa de error tanto en el conjunto de entrenamiento como en los datos no observados porque no puede representar de manera efectiva la relación entre las variables de entrada y salida.
- sobreajuste: cuando un modelo estadístico coincide exactamente con sus datos de entrenamiento, pero el objetivo del algoritmo se pierde porque no puede ejecutarse con precisión contra datos no vistos, se denomina sobreajuste
Sintaxis: sklearn.model_selection.train_test_split(*arrays, test_size=Ninguno, train_size=Ninguno, random_state=Ninguno, shuffle=True, stratify=Ninguno
Parámetros:
- *arrays: secuencia de indexables. Las listas, las arrays numpy, las arrays scipy-sparse y los marcos de datos de pandas son entradas válidas.
- test_size: int o float, por defecto Ninguno. Si es flotante, debe estar entre 0,0 y 1,0 y representar el porcentaje del conjunto de datos para probar la división. Si se usa int, se refiere al número total de muestras de prueba. Si el valor es Ninguno, se utiliza el complemento del tamaño del tren. Se establecerá en 0,25 si el tamaño del tren también es Ninguno.
- train_size: int o float, por defecto Ninguno.
- random_state : int, por defecto Ninguno. Controla cómo se mezclan los datos antes de implementar la división. Para una salida repetible en varias llamadas a funciones, pase un int.
- barajar: objeto booleano, por defecto True. Si los datos se deben mezclar o no antes de dividirlos. Estratificar debe ser Ninguno si barajar = Falso.
- estratificar: objeto similar a una array, por defecto es Ninguno . Si se selecciona Ninguno, los datos se estratifican usándolos como etiquetas de clase.
Devoluciones:
división: la división de entradas de la prueba de tren se representa como una lista.
Pasos para dividir el conjunto de datos:
Paso 1: Importe los paquetes o módulos necesarios:
En este paso, importamos los paquetes o módulos necesarios al entorno de trabajo de Python.
Python3
# import packages import numpy as np import pandas as pd from sklearn.model_selection import train_test_split
Paso 2: Importe el marco de datos/conjunto de datos:
Aquí, cargamos el CSV usando el método pd.read_csv() de pandas y obtenemos la forma del conjunto de datos usando la función shape().
CSV utilizado:
Python3
# importing data
df = pd.read_csv('prediction.csv')
print(df.shape)
Producción:
(13, 3)
Paso 3: obtenga las variables de características X e Y:
Aquí, estamos asignando las variables X e Y en las que la variable de característica X tiene variables independientes y la variable de característica y tiene una variable dependiente.
Python3
X= df['area'] y=df['prices']
Paso 4: use la clase dividida de prueba de tren para dividir los datos en conjuntos de prueba y entrenamiento:
Aquí, la clase train_test_split() de sklearn.model_selection se usa para dividir nuestros datos en conjuntos de entrenamiento y prueba donde las variables de características se proporcionan como entrada en el método. test_size determina la parte de los datos que se incluirán en los conjuntos de prueba y se utiliza un estado aleatorio para la reproducibilidad de los datos.
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)
Ejemplo:
En este ejemplo, se importa el archivo ‘predictions.csv’. El atributo df.shape se utiliza para recuperar la forma del marco de datos. La forma de la trama de datos es (13,3). Las columnas de características se toman en la variable X y la columna de resultado se toma en la variable y. Las variables X e Y se pasan en el método train_test_split() para dividir el marco de datos en conjuntos de entrenamiento y prueba. El parámetro de estado aleatorio se utiliza para la reproducibilidad de los datos. test_size se da como 0,25, lo que significa que el 25% de los datos van a los conjuntos de prueba. 4 de las 13 filas en el marco de datos van a los conjuntos de prueba. El 75% de los datos van a los conjuntos de trenes, que son 9 filas de 13 filas. Los conjuntos de trenes se utilizan para ajustar y entrenar el modelo de aprendizaje automático. Los conjuntos de prueba se utilizan para la evaluación.
CSV utilizado:
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)
Producción:
(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,)
Ejemplo:
En este ejemplo se ejecutan los siguientes pasos:
- Se importan los paquetes necesarios.
- El conjunto de datos de Advertising.csv se carga y limpia, y los valores nulos se eliminan.
- Se crean arrays de características y objetivos (X andy).
- Las arrays creadas se dividen en conjuntos de entrenamiento y prueba. El 30% del conjunto de datos va al conjunto de prueba, lo que significa que el 70% de los datos es un conjunto de trenes.
- Se crea un objeto escalador estándar.
- X_train se ajusta al escalador.
- X_train y X_test se transforman usando el método transform().
- Se crea un modelo de regresión lineal simple
- Los juegos de trenes encajan en el modelo.
- el método predict() se usa para realizar predicciones en el conjunto X_test.
- La métrica mean_squared_error() se utiliza para evaluar el modelo.
Para ver y descargar el archivo CSV utilizado en este ejemplo, haga clic aquí .
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))
Producción:
array ([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
Ejemplo:
En este ejemplo, vamos a utilizar el modelo clasificador de K-vecinos más cercanos.
En este ejemplo se ejecutan los siguientes pasos:
- Se importan los paquetes necesarios.
- Los datos del iris se cargan desde sklearn.datasets.
- Se crean arrays de características y objetivos (X andy).
- Las arrays creadas se dividen en conjuntos de entrenamiento y prueba. El 30% del conjunto de datos va al conjunto de prueba, lo que significa que el 70% de los datos es un conjunto de trenes.
- Se crea un modelo Knn básico usando la clase KNeighborsClassifier.
- Los juegos de trenes encajan en el modelo knn.
- el método predict() se usa para realizar predicciones en el conjunto 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))
Producción:
[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]
Publicación traducida automáticamente
Artículo escrito por sarahjane3102 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA