13

在将数据集拆分为测试集和训练集后，我在训练集上应用了逻辑回归，但出现了上述错误。我试图解决它，当我尝试在控制台中打印我的响应向量 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

同时，我浏览了未答复的链接。有没有解决办法。

4

6 回答 6

16

这里的问题是，无论出于何种原因，您的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。

于 2017-05-09T12:57:41.157 回答
4

我有同样的问题使用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将随机化集合的参数。

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

于 2019-09-02T23:06:02.580 回答
2

我发现这是因为我的 y_test 中只有 1 或 0 结束，因为我的样本量非常小。尝试更改您的 test_size 值。

于 2019-07-02T16:22:12.770 回答
2 
# 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)
于 2019-10-01T09:32:20.880 回答
0

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

于 2021-03-17T17:49:06.290 回答
-2

此错误与您正在使用的数据集有关，该数据集包含一个类，例如 1/benign，而它必须包含两个类 1 和 0 或 Benign 和 Attack。

于 2021-04-11T23:02:39.190 回答