Question

我有9164分，其中4303被标记为我想要预测的类，4861被标记为不是该类。它们没有重复点。

关注How to split into train, test and evaluation sets in sklearn?，由于我的dataset是3项（id，vector，label）的元组，我这样做：

df = pd.DataFrame(dataset)
train, validate, test = np.split(df.sample(frac=1), [int(.6*len(df)), int(.8*len(df))])

train_labels = construct_labels(train)
train_data = construct_data(train)

test_labels = construct_labels(test)
test_data = construct_data(test)

def predict_labels(test_data, classifier):
    labels = []
    for test_d in test_data:
        labels.append(classifier.predict([test_d]))
    return np.array(labels)

def construct_labels(df):
    labels = []
    for index, row in df.iterrows():
        if row[2] == 'Trump':
            labels.append('Atomium')
        else:
            labels.append('Not Trump')
    return np.array(labels)

def construct_data(df):
    first_row = df.iloc[0]
    data = np.array([first_row[1]])
    for index, row in df.iterrows():
        if first_row[0] != row[0]:
            data = np.concatenate((data, np.array([row[1]])), axis=0)
    return data

然后：

>>> classifier = SVC(verbose=True)
>>> classifier.fit(train_data, train_labels)
[LibSVM].......*..*
optimization finished, #iter = 9565
obj = -2718.376533, rho = 0.132062
nSV = 5497, nBSV = 2550
Total nSV = 5497
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=True)
>>> predicted_labels = predict_labels(test_data, classifier)
>>> for p, t in zip(predicted_labels, test_labels):
...     if p == t:
...             correct = correct + 1

我在1833年只得到正确的943个标签（= len（test_labels）） - ＆gt; （943 * 100/1843 = 51.4％）

我怀疑我在这里错过了很多时间，也许我应该在分类器中设置一个parameter来做更精致的工作或其他什么？

注意：第一次在这里使用SVM，所以你可能认为理所当然，我甚至可能没想到......

尝试：

我去了阴影并将负面例子的数量减少到4303（与正例相同）。这略微提高了准确度。

回答后编辑：

>>> print(clf.best_estimator_)
SVC(C=1000.0, cache_size=200, class_weight='balanced', coef0=0.0,
  decision_function_shape=None, degree=3, gamma=0.0001, kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)
>>> classifier = SVC(C=1000.0, cache_size=200, class_weight='balanced', coef0=0.0,
...   decision_function_shape=None, degree=3, gamma=0.0001, kernel='rbf',
...   max_iter=-1, probability=False, random_state=None, shrinking=True,
...   tol=0.001, verbose=False)
>>> classifier.fit(train_data, train_labels)
SVC(C=1000.0, cache_size=200, class_weight='balanced', coef0=0.0,
  decision_function_shape=None, degree=3, gamma=0.0001, kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

我也试过clf.fit(train_data, train_labels)，表现相同。

使用数据编辑（数据不是随机的）：

>>> train_data[0]
array([  20.21062112,   27.924016  ,  137.13815308,  130.97432804,
        ... # there are 256 coordinates in total
         67.76352596,   56.67798138,  104.89566517,   10.02616417])
>>> train_labels[0]
'Not Trump'
>>> train_labels[1]
'Trump'

Answer 1

像SVC这样的scikit-learn中的大多数估计器都是使用许多输入参数启动的，也称为超参数。根据您的数据，您必须在初始化期间确定要作为输入传递给估算器的内容。如果您查看scikit-learn中的SVC文档，您会看到它可以使用几个不同的输入参数进行初始化。

为简单起见，让我们考虑内核，它可以是＆＃39; rbf＆＃39;或“线性”（在其他一些选择中）;和C这是一个惩罚参数，你想为C尝试值0.01,0.1,1,10,100。这将导致创建和评估10种不同的可能模型。

一个简单的解决方案是编写两个嵌套的for循环，一个用于内核，另一个用于C，并创建10个可能的模型，并查看哪个是最好的模型。但是，如果你有几个超级参数需要调优，那么你必须编写几个嵌套的for循环，这可能很乏味。

幸运的是，scikit learn有一种更好的方法可以根据超模型的不同值组合创建不同的模型，并选择最佳模型。为此，您使用GridSearchCV。 GridSearchCV使用两个东西进行初始化：估计器的实例，超参数字典和要检查的所需值。然后，它将运行并创建所有可能的模型，给定超参数的选择并找到最佳的模型，因此您不需要编写任何嵌套的for循环。这是一个例子：

from sklearn.grid_search import GridSearchCV
print("Fitting the classifier to the training set")
param_grid = {'C': [0.01, 0.1, 1, 10, 100], 'kernel': ['rbf', 'linear']}
clf = GridSearchCV(SVC(class_weight='balanced'), param_grid)
clf = clf.fit(train_data, train_labels)
print("Best estimator found by grid search:")
print(clf.best_estimator_)

您需要使用与此示例类似的内容，并使用不同的超参数。如果您的超参数有很多种值，那么您很有可能会以这种方式找到更好的模型。

然而，GridSearchCV可能需要很长时间才能创建所有这些模型以找到最佳模型。更实际的方法是使用RandomizedSearchCV，它随机创建所有可能模型的子集（使用超参数）。如果你有很多超参数，它应该运行得更快，而它最好的模型通常都很好。

Answer 2

在sascha的评论和shahins的回答之后，我最终做到了这一点：

df = pd.DataFrame(dataset)
train, validate, test = np.split(df.sample(frac=1), [int(.6*len(df)), int(.8*len(df))])

train_labels = construct_labels(train)
train_data = construct_data(train)

test_labels = construct_labels(test)
test_data = construct_data(test)

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
train_data = scaler.fit_transform(train_data)

from sklearn.svm import SVC
# Classifier found with shahins' answer
classifier = SVC(C=10, cache_size=200, class_weight='balanced', coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)
classifier = classifier.fit(train_data, train_labels)

test_data = scaler.fit_transform(test_data)
predicted_labels = predict_labels(test_data, classifier)

得到了：

>>> correct_labels = count_correct_labels(predicted_labels, test_labels)
>>> print_stats(correct_labels, len(test_labels))
Correct labels = 1624
Accuracy = 88.5979268958

使用这些方法：

def count_correct_labels(predicted_labels, test_labels):
    correct = 0
    for p, t in zip(predicted_labels, test_labels):
        if p[0] == t:
            correct = correct + 1
    return correct

def print_stats(correct_labels, len_test_labels):
    print "Correct labels = " + str(correct_labels)
    print "Accuracy = " + str((correct_labels * 100 / float(len_test_labels)))

我能够通过更多超参数调整来优化更多！

有用的链接：RBF SVM parameters

注意：如果我不对test_data进行转换，则准确度为52.7％。

sklearn SVM表现非常糟糕

2 个答案: