0

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

        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)

我也只需要对测试集预测列进行二值化:)

4

1 回答 1

1

实际问题是您使用文本的方式，您应该提取某种特征并将其用作文本表示。例如，您可以使用词袋表示、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()

给你

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

        |  |  |
        v  |  v
       abc | fff
           v
          cde

更新

最后，要使用标签而不是它们的二值化进行预测，您需要存储二值化器

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]
于 2015-12-15T15:17:34.040 回答