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，在函数中，我正在传递列列表，我想要labelencode和dataframe，我想应用这个。

如果我们有单列来做标签编码和它的逆变换，当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

假设你只是想获得一个sklearn.预处理. labelencoder()对象，可以用来表示你的列，你所要做的就是:

le.fit(df.columns)

在上面的代码中，每一列都有一个唯一的数字。 更精确地说，你将得到df的1:1映射。列到le.transform(df.columns.get_values())。要获得列的编码，只需将其传递给le.transform(…)。作为一个例子，下面将得到每一列的编码:

le.transform(df.columns.get_values())

假设你想为你所有的行标签创建一个sklearn.预处理. 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. xml文件中第一列的标签。列数组和第一行，你可以这样做:

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])])

上面的代码实现了以下功能:

使所有(列，行)对的唯一组合 将每个对表示为元组的字符串版本。这是克服LabelEncoder类不支持元组作为类名的一种变通方法。 将新项目贴合到LabelEncoder。

现在要使用这个新模型就有点复杂了。假设我们想要提取在前一个例子中查找的同一项的表示(df中的第一列)。列和第一行)，我们可以这样做:

le.transform([str((df.columns[0], df.get_value(0, df.columns[0])))])

记住，现在每个查找都是一个元组的字符串表示 包含(列、行)。

我们不需要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'}}

使用Neuraxle

TLDR;你可以在这里使用flatforeach包装类简单地转换你的df，如:

使用这种方法，您的标签编码器将能够在常规的scikit-learn Pipeline中适应和转换。让我们简单地导入:

from sklearn.preprocessing import LabelEncoder
from neuraxle.steps.column_transformer import ColumnTransformer
from neuraxle.steps.loop import FlattenForEach

列的共享编码器相同:

下面是一个共享的LabelEncoder将如何应用于所有数据来编码:

    p = FlattenForEach(LabelEncoder(), then_unflatten=True)

结果:

    p, predicted_output = p.fit_transform(df.values)
    expected_output = np.array([
        [6, 7, 6, 8, 7, 7],
        [1, 3, 0, 1, 5, 3],
        [4, 2, 2, 4, 4, 2]
    ]).transpose()
    assert np.array_equal(predicted_output, expected_output)

每列不同的编码器:

这里是第一个独立的LabelEncoder将如何应用于宠物，第二个将为列的所有者和位置共享。所以准确地说，我们这里有一个不同的和共享的标签编码器的组合:

    p = ColumnTransformer([
        # A different encoder will be used for column 0 with name "pets":
        (0, FlattenForEach(LabelEncoder(), then_unflatten=True)),
        # A shared encoder will be used for column 1 and 2, "owner" and "location":
        ([1, 2], FlattenForEach(LabelEncoder(), then_unflatten=True)),
    ], n_dimension=2)

结果:

    p, predicted_output = p.fit_transform(df.values)
    expected_output = np.array([
        [0, 1, 0, 2, 1, 1],
        [1, 3, 0, 1, 5, 3],
        [4, 2, 2, 4, 4, 2]
    ]).transpose()
    assert np.array_equal(predicted_output, expected_output)

我们可以使用scikit learn中的OrdinalEncoder来代替LabelEncoder，它允许多列编码。

将分类特征编码为整数数组。 这个转换器的输入应该是一个类似数组的整数或字符串，表示分类(离散)特征所取的值。特征被转换为序号整数。这将导致每个特性生成一列整数(0到n_categories - 1)。

>>> from sklearn.preprocessing import OrdinalEncoder
>>> enc = OrdinalEncoder()
>>> X = [['Male', 1], ['Female', 3], ['Female', 2]]
>>> enc.fit(X)
OrdinalEncoder()
>>> enc.categories_
[array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)]
>>> enc.transform([['Female', 3], ['Male', 1]])
array([[0., 2.],
       [1., 0.]])

描述和示例都是从它的文档页面复制的，你可以在这里找到:

https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html#sklearn.preprocessing.OrdinalEncoder