Question

我正在尝试解决多标签分类问题

        from sklearn.preprocessing import MultiLabelBinarizer 

        traindf = pickle.load("traindata.pkl","rb"))
        X = traindf['Col1']
        X=MultiLabelBinarizer().fit_transform(X)

        y = traindf['Col2']
        y= MultiLabelBinarizer().fit_transform(y)

        Xtrain, Xvalidate, ytrain, yvalidate = train_test_split(X, y, test_size=.5)
        from sklearn.linear_model import LogisticRegression

        clf = OneVsRestClassifier(LogisticRegression(penalty='l2', C=0.01)).fit(Xtrain,ytrain)

        print "One vs rest accuracy: %.3f"  % clf.score(Xvalidate,yvalidate)

以这种方式，我总是得到0准确度。如果我做错了，请指出。我是多标签分类的新手。这是我的数据的样子

Col1                  Col2
asd dfgfg             [1,2,3]
poioi oiopiop         [4]

修改

感谢您的帮助@lejlot。我想我已经掌握了它。这是我试过的

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import SGDClassifier 
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import MultiLabelBinarizer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

tdf = pd.read_csv("mul.csv", index_col="DocID",error_bad_lines=False)

print tdf

所以我的输入数据看起来像

DocID   Content           Tags    
1       abc abc abc       [1]
2       asd asd asd       [2]
3       abc abc asd     [1,2]
4       asd asd abc     [1,2]
5       asd abc qwe   [1,2,3]
6       qwe qwe qwe       [3]
7       qwe qwe abc     [1,3]
8       qwe qwe asd     [2,3]

所以这只是我创建的一些测试数据。然后我做

text_clf = Pipeline([
                     ('vect', TfidfVectorizer()),
                     ('clf', SGDClassifier(loss='hinge', penalty='l2',
                                            alpha=1e-3, n_iter=5, random_state=42)),
 ])

t=TfidfVectorizer()
X=t.fit_transform(tdf["Content"]).toarray()
print X

这给了我

[[ 1.          0.          0.        ]
 [ 0.          1.          0.        ]
 [ 0.89442719  0.4472136   0.        ]
 [ 0.4472136   0.89442719  0.        ]
 [ 0.55247146  0.55247146  0.62413987]
 [ 0.          0.          1.        ]
 [ 0.40471905  0.          0.91444108]
 [ 0.          0.40471905  0.91444108]]

然后

y=tdf['Tags']
y=MultiLabelBinarizer().fit_transform(y)

print y

给了我

[[0 1 0 0 1 1]
 [0 0 1 0 1 1]
 [1 1 1 0 1 1]
 [1 1 1 0 1 1]
 [1 1 1 1 1 1]
 [0 0 0 1 1 1]
 [1 1 0 1 1 1]
 [1 0 1 1 1 1]]

这里我想知道为什么有6列？ 不应该只有3个？ 无论如何，我还创建了一个测试数据文件

sdf=pd.read_csv("multest.csv", index_col="DocID",error_bad_lines=False)
print sdf

所以这看起来像

DocID  Content        PredTags             
34     abc abc qwe    [1,3]
35     asd abc asd    [1,2]
36     abc abc abc      [1]

我有PredTags列来检查准确性。所以最后我适合并预测为

clf = OneVsRestClassifier(LogisticRegression(penalty='l2', C=0.01)).fit(X,y)
predicted = clf.predict(t.fit_transform(sdf["Content"]).toarray())
print predicted

给了我

[[1 1 1 1 1 1]
 [1 1 1 0 1 1]
 [1 1 1 0 1 1]]

现在，我如何知道预测了哪些标签？如何根据PredTags列查看准确性？

更新

非常感谢@lejlot :)我也应该按照以下方式获得准确性

sdf=pd.read_csv("multest.csv", index_col="DocID",error_bad_lines=False)
print sdf

predicted = clf.predict(t.fit_transform(sdf["Content"]).toarray())
print predicted


ty=sdf["PredTags"]
ty = [map(int, list(_y.replace(',','').replace('[','').replace(']',''))) for _y in ty]

yt=MultiLabelBinarizer().fit_transform(ty)
Xt=t.fit_transform(sdf["Content"]).toarray()

print Xt
print yt
print "One vs rest accuracy: %.3f"  % clf.score(Xt,yt)

我只需要对测试集预测列进行二值化：）

Answer 1

实际问题是您使用文本的方式，您应该extract some kind of features并将其用作文本表示。例如，您可以使用词汇表示，或tfidf，或任何更复杂的方法。

那么现在发生了什么？您在字符串列表上调用multilabelbinarizer，因此，scikit-learn在列表中创建一组所有可迭代...导致字母组表示。例如，

from sklearn.preprocessing import MultiLabelBinarizer 
X = ['abc cde', 'cde', 'fff']
print MultiLabelBinarizer().fit_transform(X)

给你

array([[1, 1, 1, 1, 1, 1, 0],
       [0, 0, 0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0, 0, 1]])

        |  |  |  |  |  |  |
        v  v  v  v  v  v  v

        a  b  _  c  d  e  f

因此，分类几乎是不可能的，因为这不能捕捉到你的文本的任何含义。

你可以做一个计数矢量化（一袋词）

from sklearn.feature_extraction.text import CountVectorizer
print CountVectorizer().fit_transform(X).toarray()

给你

更新

最后，要使用标签进行预测，而不是使用二值化进行预测，您需要存储二进制文件，因此

labels = MultiLabelBinarizer()
y = labels.fit_transform(y)

以及稍后

clf = OneVsRestClassifier(LogisticRegression(penalty='l2', C=0.01)).fit(X,y)
predicted = clf.predict(t.fit_transform(sdf["Content"]).toarray())
print labels.inverse_transform(predicted)

更新2

如果你只有三个类，那么向量应该有3个元素，你的有6个，所以检查你传递的是什么“y”，你的数据可能有些错误

from sklearn.preprocessing import MultiLabelBinarizer
MultiLabelBinarizer().fit_transform([[1,2], [1], [3], [2]])

给出

array([[1, 1, 0],
       [1, 0, 0],
       [0, 0, 1],
       [0, 1, 0]])

正如所料。

我最好的猜测是，您的“标签”也是字符串，因此您实际调用

MultiLabelBinarizer().fit_transform(["[1,2]", "[1]", "[3]", "[2]"])

导致

array([[1, 1, 1, 0, 1, 1],
       [0, 1, 0, 0, 1, 1],
       [0, 0, 0, 1, 1, 1],
       [0, 0, 1, 0, 1, 1]])

        |  |  |  |  |  | 
        v  v  v  v  v  v  

        ,  1  2  3  [  ]

这些是你的6个班级。三个真实的，2个“琐碎的”类“[”和“]”，它们存在总是，而且几乎是琐碎的类“，”对于每个对象都会出现在多个类中。

您应首先将您的代码转换为实际列表，例如

y = [map(int, list(_y.replace(',','').replace('[','').replace(']',''))) for _y in y]

OnVsRestClassifier给出0准确度

1 个答案:

更新

更新2