scikit-learnの複数列にわたるラベルエンコーディング
私は文字列ラベルのパンダLabelEncoderをエンコードするためにscikit-learnのDataFrameを使用しようとしています。データフレームには（50+）個の列があるので、各列にLabelEncoderオブジェクトを作成しないようにします。私はむしろ、1つの大きなLabelEncoderオブジェクトを持っていて、それがall私のデータ列全体に作用することを望みます。
DataFrame全体をLabelEncoderにスローすると、以下のエラーが発生します。ここではダミーデータを使用していることに注意してください。実際には約50列の文字列ラベル付きデータを扱っているので、名前で列を参照しないソリューションが必要です。
import pandas
from sklearn import preprocessing
df = pandas.DataFrame({
'pets': ['cat', 'dog', 'cat', 'monkey', 'dog', 'dog'],
'owner': ['Champ', 'Ron', 'Brick', 'Champ', 'Veronica', 'Ron'],
'location': ['San_Diego', 'New_York', 'New_York', 'San_Diego', 'San_Diego',
'New_York']
})
le = preprocessing.LabelEncoder()
le.fit(df)
トレースバック（最新の呼び出しは最後）：ファイル "/"の1行目、ファイル "/Users/bbalin/anaconda/lib/python2.7/site-packages/sklearn/preprocessing/label.py"の103行目、fit y = "column_or_1d（y、warn = True）" column_or_1dの "/Users/bbalin/anaconda/lib/python2.7/site-packages/sklearn/utils/validation.py"ファイル、行306、ValueError（ "不正な入力形状{ valueError：入力形状が正しくありません（6、3）
この問題を回避する方法について何か考えですか？
あなたは簡単にこれを行うことができます、
df.apply(LabelEncoder().fit_transform)
編集2：
Scikit-learn 0.20では、推奨される方法は
OneHotEncoder().fit_transform(df)
oneHotEncoderが文字列入力をサポートするようになりました。 ColumnTransformerを使用すると、OneHotEncoderを特定の列にのみ適用できます。
編集：
この答えは1年以上前のもので、多くの支持を得ています（賞金を含む）ので、おそらくこれをさらに拡張する必要があります。
Inverse_transformとtransformのために、あなたは少しハックをする必要があります。
from collections import defaultdict
d = defaultdict(LabelEncoder)
これで、すべての列LabelEncoderを辞書として保持するようになりました。
# Encoding the variable
fit = df.apply(lambda x: d[x.name].fit_transform(x))
# Inverse the encoded
fit.apply(lambda x: d[x.name].inverse_transform(x))
# Using the dictionary to label future data
df.apply(lambda x: d[x.name].transform(x))
Larsmansが述べたように、 LabelEncoder（）は引数として1-d配列のみを取ります 。そうは言っても、あなたが選んだ複数の列を操作し、変換されたデータフレームを返すあなた自身のラベルエンコーダーを転がすのはとても簡単です。私のコードはZac Stewartのすばらしいブログ投稿 here に一部基づいています。
カスタムエンコーダを作成するには、fit()、transform()、およびfit_transform()メソッドに応答するクラスを作成するだけです。あなたのケースでは、良いスタートはこのようなものかもしれません：
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.pipeline import Pipeline
# Create some toy data in a Pandas dataframe
fruit_data = pd.DataFrame({
'fruit': ['Apple','orange','pear','orange'],
'color': ['red','orange','green','green'],
'weight': [5,6,3,4]
})
class MultiColumnLabelEncoder:
def __init__(self,columns = None):
self.columns = columns # array of column names to encode
def fit(self,X,y=None):
return self # not relevant here
def transform(self,X):
'''
Transforms columns of X specified in self.columns using
LabelEncoder(). If no columns specified, transforms all
columns in X.
'''
output = X.copy()
if self.columns is not None:
for col in self.columns:
output[col] = LabelEncoder().fit_transform(output[col])
else:
for colname,col in output.iteritems():
output[colname] = LabelEncoder().fit_transform(col)
return output
def fit_transform(self,X,y=None):
return self.fit(X,y).transform(X)
数値属性fruitをそのままにして、2つのカテゴリカル属性（colorとweight）をエンコードするとします。次のようにしてこれを実行できます。
MultiColumnLabelEncoder(columns = ['fruit','color']).fit_transform(fruit_data)
これはfruit_dataデータセットを
に
完全にカテゴリカル変数で構成されるデータフレームを渡し、columnsパラメータを省略すると、すべての列がエンコードされます（これは元々探していたものだと思います）。
MultiColumnLabelEncoder().fit_transform(fruit_data.drop('weight',axis=1))
これは
に
。
すでに数値である属性をエンコードしようとすると、おそらく窮屈になるでしょう（これを処理するコードを追加してください）。
これについてのもう一つの素晴らしい機能は、私たちがパイプラインでこのカスタムトランスフォーマーを使うことができるということです：
encoding_pipeline = Pipeline([
('encoding',MultiColumnLabelEncoder(columns=['fruit','color']))
# add more pipeline steps as needed
])
encoding_pipeline.fit_transform(fruit_data)
LabelEncoderは必要ありません。
列をカテゴリカルに変換してからコードを取得できます。このプロセスをすべての列に適用し、結果を同一のインデックスと列名を持つ同じ形状のデータフレームに折り返すために、以下の辞書内包表記を使用しました。
>>> pd.DataFrame({col: df[col].astype('category').cat.codes for col in df}, index=df.index)
location owner pets
0 1 1 0
1 0 2 1
2 0 0 0
3 1 1 2
4 1 3 1
5 0 2 1
マッピング辞書を作成するには、辞書内包表記を使ってカテゴリを列挙するだけです。
>>> {col: {n: cat for n, cat in enumerate(df[col].astype('category').cat.categories)}
for col in df}
{'location': {0: 'New_York', 1: 'San_Diego'},
'owner': {0: 'Brick', 1: 'Champ', 2: 'Ron', 3: 'Veronica'},
'pets': {0: 'cat', 1: 'dog', 2: 'monkey'}}
列を表すために使用できるsklearn.preprocessing.LabelEncoder()オブジェクトを単純に取得しようとしていると仮定すると、必要なことは次のとおりです。
le.fit(df.columns)
上記のコードでは、各列に対応する固有の番号があります。より正確には、df.columnsとle.transform(df.columns.get_values())の1：1のマッピングがあります。列のエンコーディングを取得するには、単にそれをle.transform(...)に渡します。例として、以下は各列のエンコーディングを取得します。
le.transform(df.columns.get_values())
すべての行ラベルに対してsklearn.preprocessing.LabelEncoder()オブジェクトを作成したいと仮定すると、次のことができます。
le.fit([y for x in df.get_values() for y in x])
この場合、あなたはおそらくあなたの質問に示すように、ユニークでない行ラベルを持っています。エンコーダが作成したクラスを確認するために、le.classes_を実行できます。これはset(y for x in df.get_values() for y in x)と同じ要素を持つべきであることに気づくでしょう。もう一度行ラベルをエンコードされたラベルに変換するにはle.transform(...)を使います。たとえば、df.columns配列の最初の列と最初の行のラベルを取得したい場合は、次のようにします。
le.transform([df.get_value(0, df.columns[0])])
あなたがあなたのコメントで持っていた質問はもう少し複雑ですが、それでも達成することができます：
le.fit([str(z) for z in set((x[0], y) for x in df.iteritems() for y in x[1])])
上記のコードは次のことを行います。
- （列、行）のすべてのペアのユニークな組み合わせを作る
- 各ペアをTupleの文字列バージョンとして表します。これは、タプルをクラス名としてサポートしていない
LabelEncoderクラスを克服するための回避策です。 - 新しい項目を
LabelEncoderに合わせます。
この新しいモデルを使用するには、もう少し複雑です。前の例で見たのと同じ項目（df.columnsの最初の列と最初の行）の表現を抽出したいとすれば、これを実行できます。
le.transform([str((df.columns[0], df.get_value(0, df.columns[0])))])
各検索は、（column、row）を含むTupleの文字列表現になりました。
Scikit-learn 0.20以降、sklearn.compose.ColumnTransformerとsklearn.preprocessing.OneHotEncoderを使用できます。
カテゴリカル変数しかない場合は、直接OneHotEncoder：
from sklearn.preprocessing import OneHotEncoder
OneHotEncoder(handle_unknown='ignore').fit_transform(df)
あなたが異質的に型付けされた特徴を持っているならば：
from sklearn.compose import make_column_transformer
from sklearn.preprocessing import RobustScaler
from sklearn.preprocessing import OneHotEncoder
categorical_columns = ['pets', 'owner', 'location']
numerical_columns = ['age', 'weigth', 'height']
column_trans = make_column_transformer(
(categorical_columns, OneHotEncoder(handle_unknown='ignore'),
(numerical_columns, RobustScaler())
column_trans.fit_transform(df)
ドキュメント内の他のオプション： http://scikit-learn.org/stable/modules/compose.html#columntransformer-for-heterogeneous-data
これは直接あなたの質問に答えるものではありません（Naputipulu JonさんとPriceHardmanさんに素晴らしい回答があります）
ただし、いくつかの分類作業などを目的として使用することができます。
pandas.get_dummies(input_df)
これはカテゴリカルデータを含むデータフレームを入力し、バイナリ値を持つデータフレームを返すことができます。変数値は、結果のデータフレームの列名にエンコードされます。 もっと
これは事実から1年半後ですが、私もまた、複数のパンダデータフレーム列を一度に.transform()できるようにする必要があります（そしてそれらも.inverse_transform()できるようにする必要があります）。これは上記の@PriceHardmanの優れた提案を拡張したものです。
class MultiColumnLabelEncoder(LabelEncoder):
"""
Wraps sklearn LabelEncoder functionality for use on multiple columns of a
pandas dataframe.
"""
def __init__(self, columns=None):
self.columns = columns
def fit(self, dframe):
"""
Fit label encoder to pandas columns.
Access individual column classes via indexig `self.all_classes_`
Access individual column encoders via indexing
`self.all_encoders_`
"""
# if columns are provided, iterate through and get `classes_`
if self.columns is not None:
# ndarray to hold LabelEncoder().classes_ for each
# column; should match the shape of specified `columns`
self.all_classes_ = np.ndarray(shape=self.columns.shape,
dtype=object)
self.all_encoders_ = np.ndarray(shape=self.columns.shape,
dtype=object)
for idx, column in enumerate(self.columns):
# fit LabelEncoder to get `classes_` for the column
le = LabelEncoder()
le.fit(dframe.loc[:, column].values)
# append the `classes_` to our ndarray container
self.all_classes_[idx] = (column,
np.array(le.classes_.tolist(),
dtype=object))
# append this column's encoder
self.all_encoders_[idx] = le
else:
# no columns specified; assume all are to be encoded
self.columns = dframe.iloc[:, :].columns
self.all_classes_ = np.ndarray(shape=self.columns.shape,
dtype=object)
for idx, column in enumerate(self.columns):
le = LabelEncoder()
le.fit(dframe.loc[:, column].values)
self.all_classes_[idx] = (column,
np.array(le.classes_.tolist(),
dtype=object))
self.all_encoders_[idx] = le
return self
def fit_transform(self, dframe):
"""
Fit label encoder and return encoded labels.
Access individual column classes via indexing
`self.all_classes_`
Access individual column encoders via indexing
`self.all_encoders_`
Access individual column encoded labels via indexing
`self.all_labels_`
"""
# if columns are provided, iterate through and get `classes_`
if self.columns is not None:
# ndarray to hold LabelEncoder().classes_ for each
# column; should match the shape of specified `columns`
self.all_classes_ = np.ndarray(shape=self.columns.shape,
dtype=object)
self.all_encoders_ = np.ndarray(shape=self.columns.shape,
dtype=object)
self.all_labels_ = np.ndarray(shape=self.columns.shape,
dtype=object)
for idx, column in enumerate(self.columns):
# instantiate LabelEncoder
le = LabelEncoder()
# fit and transform labels in the column
dframe.loc[:, column] =\
le.fit_transform(dframe.loc[:, column].values)
# append the `classes_` to our ndarray container
self.all_classes_[idx] = (column,
np.array(le.classes_.tolist(),
dtype=object))
self.all_encoders_[idx] = le
self.all_labels_[idx] = le
else:
# no columns specified; assume all are to be encoded
self.columns = dframe.iloc[:, :].columns
self.all_classes_ = np.ndarray(shape=self.columns.shape,
dtype=object)
for idx, column in enumerate(self.columns):
le = LabelEncoder()
dframe.loc[:, column] = le.fit_transform(
dframe.loc[:, column].values)
self.all_classes_[idx] = (column,
np.array(le.classes_.tolist(),
dtype=object))
self.all_encoders_[idx] = le
return dframe
def transform(self, dframe):
"""
Transform labels to normalized encoding.
"""
if self.columns is not None:
for idx, column in enumerate(self.columns):
dframe.loc[:, column] = self.all_encoders_[
idx].transform(dframe.loc[:, column].values)
else:
self.columns = dframe.iloc[:, :].columns
for idx, column in enumerate(self.columns):
dframe.loc[:, column] = self.all_encoders_[idx]\
.transform(dframe.loc[:, column].values)
return dframe.loc[:, self.columns].values
def inverse_transform(self, dframe):
"""
Transform labels back to original encoding.
"""
if self.columns is not None:
for idx, column in enumerate(self.columns):
dframe.loc[:, column] = self.all_encoders_[idx]\
.inverse_transform(dframe.loc[:, column].values)
else:
self.columns = dframe.iloc[:, :].columns
for idx, column in enumerate(self.columns):
dframe.loc[:, column] = self.all_encoders_[idx]\
.inverse_transform(dframe.loc[:, column].values)
return dframe
例：
dfおよびdf_copy()が混在型のpandasデータフレームである場合は、次の方法でMultiColumnLabelEncoder()をdtype=object列に適用できます。
# get `object` columns
df_object_columns = df.iloc[:, :].select_dtypes(include=['object']).columns
df_copy_object_columns = df_copy.iloc[:, :].select_dtypes(include=['object'].columns
# instantiate `MultiColumnLabelEncoder`
mcle = MultiColumnLabelEncoder(columns=object_columns)
# fit to `df` data
mcle.fit(df)
# transform the `df` data
mcle.transform(df)
# returns output like below
array([[1, 0, 0, ..., 1, 1, 0],
[0, 5, 1, ..., 1, 1, 2],
[1, 1, 1, ..., 1, 1, 2],
...,
[3, 5, 1, ..., 1, 1, 2],
# transform `df_copy` data
mcle.transform(df_copy)
# returns output like below (assuming the respective columns
# of `df_copy` contain the same unique values as that particular
# column in `df`
array([[1, 0, 0, ..., 1, 1, 0],
[0, 5, 1, ..., 1, 1, 2],
[1, 1, 1, ..., 1, 1, 2],
...,
[3, 5, 1, ..., 1, 1, 2],
# inverse `df` data
mcle.inverse_transform(df)
# outputs data like below
array([['August', 'Friday', '2013', ..., 'N', 'N', 'CA'],
['April', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['August', 'Monday', '2014', ..., 'N', 'N', 'NJ'],
...,
['February', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['April', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['March', 'Tuesday', '2013', ..., 'N', 'N', 'NJ']], dtype=object)
# inverse `df_copy` data
mcle.inverse_transform(df_copy)
# outputs data like below
array([['August', 'Friday', '2013', ..., 'N', 'N', 'CA'],
['April', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['August', 'Monday', '2014', ..., 'N', 'N', 'NJ'],
...,
['February', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['April', 'Tuesday', '2014', ..., 'N', 'N', 'NJ'],
['March', 'Tuesday', '2013', ..., 'N', 'N', 'NJ']], dtype=object)
インデックス付けによって、個々の列クラス、列ラベル、および各列に合うように使用される列エンコーダにアクセスできます。
mcle.all_classes_mcle.all_encoders_mcle.all_labels_
いいえ、LabelEncoderはこれを行いません。クラスラベルの1次元配列を受け取り、1次元配列を生成します。任意のデータではなく分類問題でクラスラベルを処理するように設計されており、他の用途にそれを強制しようとすると、実際の問題を解決する問題に変換するコードが必要になります。
これらすべてを直接パンダで実行することは可能で、replaceメソッドの独自の機能に非常に適しています。
まず、列とその値を新しい置換値にマッピングする辞書の辞書を作りましょう。
transform_dict = {}
for col in df.columns:
cats = pd.Categorical(df[col]).categories
d = {}
for i, cat in enumerate(cats):
d[cat] = i
transform_dict[col] = d
transform_dict
{'location': {'New_York': 0, 'San_Diego': 1},
'owner': {'Brick': 0, 'Champ': 1, 'Ron': 2, 'Veronica': 3},
'pets': {'cat': 0, 'dog': 1, 'monkey': 2}}
これは常に1対1のマッピングになるので、新しい値のマッピングを元のものに戻すために内側の辞書を反転することができます。
inverse_transform_dict = {}
for col, d in transform_dict.items():
inverse_transform_dict[col] = {v:k for k, v in d.items()}
inverse_transform_dict
{'location': {0: 'New_York', 1: 'San_Diego'},
'owner': {0: 'Brick', 1: 'Champ', 2: 'Ron', 3: 'Veronica'},
'pets': {0: 'cat', 1: 'dog', 2: 'monkey'}}
これで、replaceメソッドのユニークな機能を使用して辞書のネストリストを取得し、外側のキーを列として使用し、内側のキーを置換する値として使用できます。
df.replace(transform_dict)
location owner pets
0 1 1 0
1 0 2 1
2 0 0 0
3 1 1 2
4 1 3 1
5 0 2 1
replaceメソッドを再度チェインすることで簡単に元に戻ることができます。
df.replace(transform_dict).replace(inverse_transform_dict)
location owner pets
0 San_Diego Champ cat
1 New_York Ron dog
2 New_York Brick cat
3 San_Diego Champ monkey
4 San_Diego Veronica dog
5 New_York Ron dog
ここと他の場所でいくつかの答えを求めてたくさんの検索と実験をした結果、あなたの答えは here ：
pd.DataFrame（columns = df.columns、data = LabelEncoder（）。fit_transform（df.values.flatten（））。reshape（df.shape））
これは列を越えてカテゴリ名を保存します：
import pandas as pd
from sklearn.preprocessing import LabelEncoder
df = pd.DataFrame([['A','B','C','D','E','F','G','I','K','H'],
['A','E','H','F','G','I','K','','',''],
['A','C','I','F','H','G','','','','']],
columns=['A1', 'A2', 'A3','A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10'])
pd.DataFrame(columns=df.columns, data=LabelEncoder().fit_transform(df.values.flatten()).reshape(df.shape))
A1 A2 A3 A4 A5 A6 A7 A8 A9 A10
0 1 2 3 4 5 6 7 9 10 8
1 1 5 8 6 7 9 10 0 0 0
2 1 3 9 6 8 7 0 0 0 0
LabelEncoderのソースコード（ https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/preprocessing/label.py ）を確認しました。それは一連の派手な変換に基づいていました、それらのうちの1つはnp.unique（）です。そしてこの関数は1次元配列入力のみを取ります。 （私が間違っているなら私を直してください）。
非常に大まかなアイデア...まず、どの列がLabelEncoderを必要としているのかを特定してから、各列をループします。
def cat_var(df):
"""Identify categorical features.
Parameters
----------
df: original df after missing operations
Returns
-------
cat_var_df: summary df with col index and col name for all categorical vars
"""
col_type = df.dtypes
col_names = list(df)
cat_var_index = [i for i, x in enumerate(col_type) if x=='object']
cat_var_name = [x for i, x in enumerate(col_names) if i in cat_var_index]
cat_var_df = pd.DataFrame({'cat_ind': cat_var_index,
'cat_name': cat_var_name})
return cat_var_df
from sklearn.preprocessing import LabelEncoder
def column_encoder(df, cat_var_list):
"""Encoding categorical feature in the dataframe
Parameters
----------
df: input dataframe
cat_var_list: categorical feature index and name, from cat_var function
Return
------
df: new dataframe where categorical features are encoded
label_list: classes_ attribute for all encoded features
"""
label_list = []
cat_var_df = cat_var(df)
cat_list = cat_var_df.loc[:, 'cat_name']
for index, cat_feature in enumerate(cat_list):
le = LabelEncoder()
le.fit(df.loc[:, cat_feature])
label_list.append(list(le.classes_))
df.loc[:, cat_feature] = le.transform(df.loc[:, cat_feature])
return df, label_list
返された df エンコード後のものになります label_list 対応する列で、これらすべての値の意味を説明します。これは私が仕事のために書いたデータ処理スクリプトからの抜粋です。あなたはそれ以上の改善があるかもしれないと思うかどうか私に知らせてください。
編集：ここで言及しておきたいのは、上記の方法はデータフレームでもうまくいくことです。データフレームに対してどのように機能しているのかわからない場合は、欠損データが含まれます。 （私は上記のメソッドを実行する前に不足している手順に対処しました）
@ PriceHardman の解決策について寄せられたコメントをフォローアップするために、以下のバージョンを提案します。
class LabelEncodingColoumns(BaseEstimator, TransformerMixin):
def __init__(self, cols=None):
pdu._is_cols_input_valid(cols)
self.cols = cols
self.les = {col: LabelEncoder() for col in cols}
self._is_fitted = False
def transform(self, df, **transform_params):
"""
Scaling ``cols`` of ``df`` using the fitting
Parameters
----------
df : DataFrame
DataFrame to be preprocessed
"""
if not self._is_fitted:
raise NotFittedError("Fitting was not preformed")
pdu._is_cols_subset_of_df_cols(self.cols, df)
df = df.copy()
label_enc_dict = {}
for col in self.cols:
label_enc_dict[col] = self.les[col].transform(df[col])
labelenc_cols = pd.DataFrame(label_enc_dict,
# The index of the resulting DataFrame should be assigned and
# equal to the one of the original DataFrame. Otherwise, upon
# concatenation NaNs will be introduced.
index=df.index
)
for col in self.cols:
df[col] = labelenc_cols[col]
return df
def fit(self, df, y=None, **fit_params):
"""
Fitting the preprocessing
Parameters
----------
df : DataFrame
Data to use for fitting.
In many cases, should be ``X_train``.
"""
pdu._is_cols_subset_of_df_cols(self.cols, df)
for col in self.cols:
self.les[col].fit(df[col])
self._is_fitted = True
return self
このクラスは、エンコーダをトレーニングセットに適合させ、変換時には適合バージョンを使用します。コードの初期バージョンは こちら にあります。
ラベルエンコーディングとその逆変換を行うための単一の列がある場合、pythonに複数の列があるときにそれを簡単に行う方法
def stringtocategory(dataset):
'''
@author puja.sharma
@see The function label encodes the object type columns and gives label encoded and inverse tranform of the label encoded data
@param dataset dataframe on whoes column the label encoding has to be done
@return label encoded and inverse tranform of the label encoded data.
'''
data_original = dataset[:]
data_tranformed = dataset[:]
for y in dataset.columns:
#check the dtype of the column object type contains strings or chars
if (dataset[y].dtype == object):
print("The string type features are : " + y)
le = preprocessing.LabelEncoder()
le.fit(dataset[y].unique())
#label encoded data
data_tranformed[y] = le.transform(dataset[y])
#inverse label transform data
data_original[y] = le.inverse_transform(data_tranformed[y])
return data_tranformed,data_original
データフレームに数値とカテゴリカルの両方のタイプのデータがある場合使用できます。
from sklearn import preprocessing
le = preprocessing.LabelEncoder()
for i in range(0,X.shape[1]):
if X.dtypes[i]=='object':
X[X.columns[i]] = le.fit_transform(X[X.columns[i]])
注意：この方法は、変換したくない場合に適しています。
import pandas as pd
from sklearn.preprocessing import LabelEncoder
train=pd.read_csv('.../train.csv')
#X=train.loc[:,['waterpoint_type_group','status','waterpoint_type','source_class']].values
# Create a label encoder object
def MultiLabelEncoder(columnlist,dataframe):
for i in columnlist:
labelencoder_X=LabelEncoder()
dataframe[i]=labelencoder_X.fit_transform(dataframe[i])
columnlist=['waterpoint_type_group','status','waterpoint_type','source_class','source_type']
MultiLabelEncoder(columnlist,train)
ここで私は位置からcsvを読んでいてそして機能で私は私がラベルを付けたい列リストと私がこれを適用したいデータフレームを渡しています。
主に@Alexanderの回答を使用しましたが、いくつかの変更を加える必要がありました -
cols_need_mapped = ['col1', 'col2']
mapper = {col: {cat: n for n, cat in enumerate(df[col].astype('category').cat.categories)}
for col in df[cols_need_mapped]}
for c in cols_need_mapped :
df[c] = df[c].map(mapper[c])
それから、将来再利用するために、出力をjsonドキュメントに保存し、必要に応じてそれを読み込んで、上記のように.map()関数を使用することができます。
LabelEncoder()を使って複数の列をdict()する簡単な方法：
from sklearn.preprocessing import LabelEncoder
le_dict = {col: LabelEncoder() for col in columns }
for col in columns:
le_dict[col].fit_transform(df[col])
そして、このle_dictを使って他の列をlabelEncodeすることができます。
le_dict[col].transform(df_another[col])
問題は、fit関数に渡すデータの形状（pdデータフレーム）です。あなたは1dリストに合格する必要があります。