ValueError:此求解器需要数据中至少 2 个类的样本，但数据仅包含一个类:0.0

Question

在将数据集拆分为测试和训练集后，我已经在训练集上应用了逻辑回归，但我得到了上述错误。我试图解决这个问题，当我尝试在控制台中打印我的响应向量y_train时，它会打印 0 或 1 等整数值。但是当我把它写进一个文件时，我发现这些值是浮点数，如 0.0 和 1.0。如果这就是问题所在，我怎么能克服它。

lenreg = LogisticRegression()
print y_train[0:10]
y_train.to_csv(path='ytard.csv')
lenreg.fit(X_train, y_train)
y_pred = lenreg.predict(X_test)
print metics.accuracy_score(y_test, y_pred)

StrackTrace如下，

Traceback (most recent call last):
  File "/home/amey/prog/pd.py", line 82, in <module>
    lenreg.fit(X_train, y_train)
  File "/usr/lib/python2.7/dist-packages/sklearn/linear_model/logistic.py", line 1154, in fit
    self.max_iter, self.tol, self.random_state)
  File "/usr/lib/python2.7/dist-packages/sklearn/svm/base.py", line 885, in _fit_liblinear
    " class: %r" % classes_[0])
ValueError: This solver needs samples of at least 2 classes in the data, but the data contains only one class: 0.0

与此同时，我已经浏览了未回答的链接。有没有解决方案。

Answer 1

这里的问题是，无论出于何种原因，你的y_train向量只有零。 这实际上不是你的错，它是一种错误(我认为(。 分类器需要 2 个类，否则会引发此错误。

这是有道理的。 如果你的y_train向量只有零(即只有 1 个类(，那么分类器实际上不需要做任何工作，因为所有的预测都应该只是一个类。

在我看来，分类器仍然应该完成并只预测一个类(在这种情况下全为零(，然后抛出警告，但它没有。 它会抛出错误。

检查此条件的一种方法如下所示：

lenreg = LogisticRegression()
print y_train[0:10]
y_train.to_csv(path='ytard.csv')
if len(np.sum(y_train)) in [len(y_train),0]:
    print "all one class"
    #do something else
else:
    #OK to proceed
    lenreg.fit(X_train, y_train)
    y_pred = lenreg.predict(X_test)
    print metics.accuracy_score(y_test, y_pred)

为了更容易地克服这个问题，我建议在你的测试集中包含更多的样本，比如 100 或 1000 而不是 10。

Answer 2

我在使用learning_curve时遇到了同样的问题：

 train_sizes, train_scores, test_scores = learning_curve(estimator,
           X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes,
           scoring="f1", random_state=RANDOM_SEED, shuffle=True)

添加将随机化集合的 suffle 参数。

这并不能防止错误发生，但这是一种增加函数使用的子集中同时存在这两个类的机会的方法。

Answer 3

我发现这是因为我的y_test中只有 1 或 0，因为我的样本量真的很小。尝试追逐您的test_size价值。

Answer 4

# python3
import numpy as np
from sklearn.svm import LinearSVC
def upgrade_to_work_with_single_class(SklearnPredictor):
    class UpgradedPredictor(SklearnPredictor):
        def __init__(self, *args, **kwargs):
            self._single_class_label = None
            super().__init__(*args, **kwargs)
        @staticmethod
        def _has_only_one_class(y):
            return len(np.unique(y)) == 1
        def _fitted_on_single_class(self):
            return self._single_class_label is not None
        def fit(self, X, y=None):
            if self._has_only_one_class(y):
                self._single_class_label = y[0]
            else:
                super().fit(X, y)
            return self
        def predict(self, X):
            if self._fitted_on_single_class():
                return np.full(X.shape[0], self._single_class_label)
            else:
                return super().predict(X)
    return UpgradedPredictor
LinearSVC = upgrade_to_work_with_single_class(LinearSVC)

或硬路(更右(：

import numpy as np
from sklearn.svm import LinearSVC
from copy import deepcopy, copy
from functools import wraps
def copy_class(cls):
    copy_cls = type(f'{cls.__name__}', cls.__bases__, dict(cls.__dict__))
    for name, attr in cls.__dict__.items():
        try:
            hash(attr)
        except TypeError:
            # Assume lack of __hash__ implies mutability. This is NOT
            # a bullet proof assumption but good in many cases.
            setattr(copy_cls, name, deepcopy(attr))
    return copy_cls
def upgrade_to_work_with_single_class(SklearnPredictor):
    SklearnPredictor = copy_class(SklearnPredictor)
    original_init = deepcopy(SklearnPredictor.__init__)
    original_fit = deepcopy(SklearnPredictor.fit)
    original_predict = deepcopy(SklearnPredictor.predict)
    @staticmethod
    def _has_only_one_class(y):
        return len(np.unique(y)) == 1
    def _fitted_on_single_class(self):
        return self._single_class_label is not None
    @wraps(SklearnPredictor.__init__)
    def new_init(self, *args, **kwargs):
        self._single_class_label = None
        original_init(self, *args, **kwargs)
    @wraps(SklearnPredictor.fit)
    def new_fit(self, X, y=None):
        if self._has_only_one_class(y):
            self._single_class_label = y[0]
        else:
            original_fit(self, X, y)
        return self
    @wraps(SklearnPredictor.predict)
    def new_predict(self, X):
        if self._fitted_on_single_class():
            return np.full(X.shape[0], self._single_class_label)
        else:
            return original_predict(self, X)
    setattr(SklearnPredictor, '_has_only_one_class', _has_only_one_class)
    setattr(SklearnPredictor, '_fitted_on_single_class', _fitted_on_single_class)
    SklearnPredictor.__init__ = new_init
    SklearnPredictor.fit = new_fit
    SklearnPredictor.predict = new_predict
    return SklearnPredictor
LinearSVC = upgrade_to_work_with_single_class(LinearSVC)

Answer 5

您可以找到每个类第一次(或任何(出现的索引，并将它们连接在数组之上并将它们从其原始位置删除，这样训练集中每个类至少有一个实例。

Answer 6

此错误

与您正在使用的数据集有关，数据集包含一个类，例如 1/良性，而它必须包含两个类 1 和 0 或良性和攻击。