我正在尝试解决多标签分类问题
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)
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)
我只需要对测试集预测列进行二值化：）
答案 0 :(得分：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()
给你
[[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)
如果你只有三个类，那么向量应该有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]