Estoy usando un codificador de etiquetas durante el entrenamiento y quiero usar el mismo codificador en producción guardándolo y cargándolo más tarde. Cualquier solución que haya encontrado en línea solo permite que Label Encoder se aplique en una sola columna en un momento como el siguiente:
for col in col_list: df[col]= df[[col]].apply(LabelEncoder().fit_transform)En este caso, ¿cómo lo guardo y lo uso más tarde? Porque traté de encajar en todo el marco de datos pero recibo el siguiente error.
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) C:\Users\DA~1\AppData\Local\Temp/ipykernel_3884/730613134.py in <module> ----> 1 l_enc.fit_transform(df_join[le_col].astype(str)) ~\anaconda3\envs\ReturnRate\lib\site-packages\sklearn\preprocessing\_label.py in fit_transform(self, y) 113 Encoded labels. 114 """ --> 115 y = column_or_1d(y, warn=True) 116 self.classes_, y = _unique(y, return_inverse=True) 117 return y ~\anaconda3\envs\ReturnRate\lib\site-packages\sklearn\utils\validation.py in column_or_1d(y, warn) 1022 return np.ravel(y) 1023 -> 1024 raise ValueError( 1025 "y should be a 1d array, got an array of shape {} instead.".format(shape) 1026 ) ValueError: y should be a 1d array, got an array of shape (3949037, 14) instead.Quiero ajustar el codificador de etiquetas al marco de datos con 10 columnas (todas categóricas), guardarlo y cargarlo más tarde en producción.
Primero, quiero señalar que labelEncoder está diseñado para codificar variables de destino. Si aplica labelEncoder en sus variables predictoras, las está haciendo continuas, por ejemplo, 0,1,2,3, etc., lo que puede no tener sentido.
Para los predictores categóricos, debe usar onehotencoding .
Si está seguro de labelencode, es así:
from sklearn.preprocessing import LabelEncoder import pandas as pd import numpy as np df = pd.DataFrame({'f1':np.random.choice(['a','b','c'],100), 'f2':np.random.choice(['x','y','z'],100)}) col_list = ['f1','f2'] df[col_list].apply(LabelEncoder().fit_transform)Si desea conservar el codificador, puede almacenarlo en un diccionario:
le = {} for col in col_list: le[col] = LabelEncoder().fit(df[col].values) le['f1'].transform(df['f1']) array([1, 0, 2, 0, 2, 0, 2, 1, 1, 2, 0, 1, 2, 1, 1, 1, 0, 2, 1, 2, 1, 2, 2, 2, 0, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 1, 1, 0, 1, 1, 1, 2, 2, 1, 0, 2, 1, 2, 2, 2, 1, 0, 0, 2, 2, 0, 1, 2, 2, 0, 2, 1, 2, 1, 1, 1, 1, 1, 2, 2, 0, 2, 0, 1, 1, 1, 0, 2, 0, 0, 2, 0, 1, 1, 2, 1, 0, 0, 2, 0, 1, 1, 2]) for col in col_list: df[col] = le[col].transform(df[col])Nuevamente, pensaría más sobre si es correcto usar labelEncoding.
Como dijo @StupidWolf , LabelEncoder debe usarse únicamente para codificar la variable de destino.
scikit-learn ofrece múltiples formas de codificar variables categóricas para vectores de características:
OneHotEncoder que codifica categorías en valores numéricos calientesOrdinalEncoder que codifica categorías en valores numéricos. OrdinalEncoder realiza la misma operación que LabelEncoder pero para valores de características.
Puede usar ColumnTransformer para envolver diferentes preprocesamientos en un objeto que luego se puede guardar fácilmente usando pickle como en el ejemplo a continuación:
from sklearn.compose import make_column_transformer, make_column_selector from sklearn.preprocessing import OrdinalEncoder import pandas as pd import numpy as np df = pd.DataFrame( { "col_1": ["A", "B", "B", "D", "E", "F", "A", "B"], "col_2": ["X", "X", "X", "Y", "Y", "Z", "Z", "X"], "col_3": [42] * 8, } ) cols = ["col_1", "col_2"] pre_processeing = make_column_transformer( (OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=np.nan), cols) ) df.loc[:, cols] = pre_processeing.fit_transform(df[cols])Qué salida:
col_1 col_2 col_3 0 0.0 0.0 42 1 1.0 0.0 42 2 1.0 0.0 42 3 2.0 1.0 42 4 3.0 1.0 42 5 4.0 2.0 42 6 0.0 2.0 42 7 1.0 0.0 42 Una vez que se coloca el preprocesamiento, se puede almacenar y cargar fácilmente usando pickle de la siguiente manera:
import pickle #Dump preprocessing pickle.dump(pre_processeing, open("pre_processing.p", "wb")) #Load preprocessing pre_processeing = pickle.load(open("pre_processing.p", "rb")) Para concluir, recomendaría que ColumnTransformer tenga los siguientes beneficios:
StandardScaler para valores numéricos)Pipeline para tener un modelo de extremo a extremo que realice predicciones.pickle .TL; DR Use
SklearnTransformerWrapperde la biblioteca del motor de características
from feature_engine.wrappers import SklearnTransformerWrapper multi_col_transformer = SklearnTransformerWrapper( transformer=# your sklearn- transformer, variables=# variables to apply transformation to ) Si está buscando un enfoque con una biblioteca diferente, los codificadores categóricos del motor de funciones aceptan un parámetro de variables para aplicar el cálculo a varias columnas. Otro enfoque es usar SklearnTransformerWrapper para aplicar cualquier transformador Scikit-learn a un grupo de variables.
from feature_engine.wrappers import SklearnTransformerWrapper from sklearn.preprocessing import OrdinalEncoder import pandas as pd import joblib transformer_name = 'multi_col_encoder.joblib' cols_list = [ 'country', 'category' ] d_train = { 'country': ['AR', 'AR', 'MEX', 'BR', 'MEX'], 'category': ['Small', 'High', 'High', 'Medium', 'Small'] } d_unknown = { 'country': ['BR', 'AR', 'MEX'], 'category': ['High', 'Medium', 'Small'] } df_train = pd.DataFrame(d_train) df_unknown = pd.DataFrame(d_unknown) # Apply a sklearn enconder to multiple columns with SklearnTransformerWrapper multi_col_oe = SklearnTransformerWrapper( transformer=OrdinalEncoder( handle_unknown='use_encoded_value', unknown_value=-1 ), variables=cols_list ) df_train = multi_col_oe.fit_transform(df_train) df_train >>> country category 0 0.0 2.0 1 0.0 0.0 2 2.0 0.0 3 1.0 1.0 4 2.0 2.0 # Dump transformer to use later joblib.dump(multi_col_oe, transformer_name) # Load transformer with learned encoder logic transformer_for_prod = joblib.load(transformer_name) # Apply transformer to unknown data transformer_for_prod.transform(df_unknown) >>> country category 0 1.0 0.0 1 0.0 1.0 2 2.0 2.0 Como dijo @StupidWolf, si está asumiendo el orden en sus variables categóricas, debe usar OrdinalEncoder en lugar de LabelEncoder . Aunque realizan cálculos similares, OrdinalEncoder le permite manejar valores desconocidos que puede encontrar más adelante.
Finalmente, los codificadores categóricos de Feature Engine también ofrecen otras posibilidades para codificar variables categóricas.