Xgboost: 在 Python 中使用稀疏矩阵时特征名称不匹配

这似乎只有在稀疏矩阵是 CSC 时才有效。 它不适用于早期版本的 CSR 或 COO 矩阵。

当最右边的列都是 0 或 1 时，这不是随机问题吗？ 可能与#1091 和#1221 相同。

@sinhrks ：对我来说，这不是“随机”。 我经常在高度稀疏的数据上训练 XGBoost（这太棒了！它通常击败所有其他模型，而且幅度相当大）。

然后，一旦我在生产中运行了经过训练的模型，我当然想对新的传入数据进行预测。 当然，该数据很可能是稀疏的，并且对于恰好是最后一列的任何列都没有值。 所以 XGBoost 现在对我来说经常中断，我发现自己切换到其他（不太准确的）模型，仅仅是因为它们对稀疏数据有更好的支持。

有谁知道现在为什么会出现这个错误以及如何解决它？ 这对我来说是一个痛点，因为我现有的脚本失败了。

我正在尝试将 xgboost 作为 sklearn 管道的一部分并遇到同样的问题。 在修复之前是否有解决方法？

是的，当你调用 predict 时，使用稀疏数组的 toarray() 函数。 它的内存效率非常低，但适用于小切片。

从我的iPhone发送

2016 年 8 月 26 日晚上 10:44，Pedro Rodriguez [email protected]写道：

我正在尝试将 xgboost 作为 sklearn 管道的一部分并遇到同样的问题。 在修复之前是否有解决方法？

—
您收到此消息是因为您发表了评论。
直接回复此邮件，在 GitHub 上查看，或将线程静音。

出于某种原因，如果我保存并加载经过训练的模型，则不会发生错误：

    bst = xgb.train(param, dtrain, num_round)

    # predict is not working without this code
    bst.save_model(model_file_name)
    bst = xgb.Booster(param)
    bst.load_model(model_file_name)

    preds = bst.predict(dtest)

@bryan-woods 我找到了更好的解决方法tocsc 。 可能会有一些性能损失，但没有使它成为一个密集矩阵那么糟糕。

在 xgboost 工作之前，将它包含在我的 sklearn 管道中

class CSCTransformer(TransformerMixin):
    def transform(self, X, y=None, **fit_params):
        return X.tocsc()

    def fit_transform(self, X, y=None, **fit_params):
        self.fit(X, y, **fit_params)
        return self.transform(X)

    def fit(self, X, y=None, **fit_params):
        return self

    def get_params(self, deep=True):
        return {}

在最新版本的 xgboost 中，CSC 格式和在最后一列中添加非零条目都不能解决此问题。 恢复到 0.4a30 版本是我唯一可以使它工作的方法，请考虑对原始示例进行以下调整（带有可重现的种子）：

>>> import xgboost as xgb
>>> import numpy as np
>>> from scipy import sparse
>>> 
>>> np.random.seed(10)
>>> X = sparse.rand(100,10).tocsr()
>>> test = sparse.rand(10, 500).tocsr()
>>> y = np.random.randint(2,size=100)
>>> 
>>> clf = xgb.XGBClassifier()
>>> clf.fit(X,y)
XGBClassifier(base_score=0.5, colsample_bylevel=1, colsample_bytree=1,
       gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3,
       min_child_weight=1, missing=None, n_estimators=100, nthread=-1,
       objective='binary:logistic', reg_alpha=0, reg_lambda=1,
       scale_pos_weight=1, seed=0, silent=True, subsample=1)
>>> 
>>> try:
...     pred = clf.predict_proba(test)
...     print "Works when csr with version %s" %xgb.__version__
... except ValueError:
...     "Broken when csr with version %s" %xgb.__version__
... 
'Broken when csr with version 0.6'
>>> try:
...     pred = clf.predict_proba(test.tocsc())
...     print "Works when csc with version %s" %xgb.__version__
... except ValueError:
...     "Still broken when csc with version %s" %xgb.__version__
... 
'Still broken when csc with version 0.6'
>>> try:
...     test[0,(test.shape[1]-1)] = 1.0
...     pred = clf.predict_proba(test)
...     print "Works when adding non-zero entries to last column with version %s" %xgb.__version__
... except ValueError:
...     "Still broken when adding non-zero entries to last column with version %s" %xgb.__version__
... 
/home/david.mcgarry/.conda/envs/ml/lib/python2.7/site-packages/scipy/sparse/compressed.py:730: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.
  SparseEfficiencyWarning)
'Still broken when adding non-zero entries to last column with version 0.6'

>>> import xgboost as xgb
>>> import numpy as np
>>> from scipy import sparse
>>> 
>>> np.random.seed(10)
>>> X = sparse.rand(100,10).tocsr()
>>> test = sparse.rand(10, 500).tocsr()
>>> y = np.random.randint(2,size=100)
>>> 
>>> clf = xgb.XGBClassifier()
>>> clf.fit(X,y)
XGBClassifier(base_score=0.5, colsample_bylevel=1, colsample_bytree=1,
       gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3,
       min_child_weight=1, missing=None, n_estimators=100, nthread=-1,
       objective='binary:logistic', reg_alpha=0, reg_lambda=1,
       scale_pos_weight=1, seed=0, silent=True, subsample=1)
>>> 
>>> try:
...     pred = clf.predict_proba(test)
...     print "Works when csr with version %s" %xgb.__version__
... except ValueError:
...     "Broken when csr with version %s" %xgb.__version__
... 
Works when csr with version 0.4
>>> try:
...     pred = clf.predict_proba(test.tocsc())
...     print "Works when csc with version %s" %xgb.__version__
... except ValueError:
...     "Still broken when csc with version %s" %xgb.__version__
... 
Works when csc with version 0.4
>>> try:
...     test[0,(test.shape[1]-1)] = 1.0
...     pred = clf.predict_proba(test)
...     print "Works when adding non-zero entries to last column with version %s" %xgb.__version__
... except ValueError:
...     "Still broken when adding non-zero entries to last column with version %s" %xgb.__version__
... 
/Users/david.mcgarry/anaconda/envs/ml/lib/python2.7/site-packages/scipy/sparse/compressed.py:739: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.
  SparseEfficiencyWarning)
Works when adding non-zero entries to last column with version 0.4

同样的问题，在上一个版本中肯定有问题。 使用相同的数据集和处理之前没有这个问题。 我可能是错的，但看起来目前没有使用 sklearn API 在 Python 中使用稀疏 csr 数组进行单元测试。 是否可以将上面的@dmcgarry示例添加到tests/python/tests_with_sklearn.py ？

我尝试使用 .toarray() 和 CSR 稀疏数组解决它，但有些东西严重损坏。 如果我加载保存的模型并尝试使用它通过 .toarray() 进行预测，我不会收到错误消息，但结果不正确。 我回滚到 0.4a30，它工作正常。 我没有时间去追查根本原因，但这并不好。

由于 DMatrix..num_col() 仅返回稀疏矩阵中非零列的数量，因此会出现问题。 因此，如果训练和测试数据具有相同数量的非零列，则一切正常。
否则，您最终会得到不同的功能名称列表，因为验证函数调用：

    <strong i="7">@property</strong>
    def feature_names(self):
        """Get feature names (column labels).

        Returns
        -------
        feature_names : list or None
        """
        if self._feature_names is None:
            return ['f{0}'.format(i) for i in range(self.num_col())]
        else:
            return self._feature_names

self._feature_names对于稀疏矩阵是 None，并且因为 self.num_col() 只返回非零列的数量，一旦“to-be-预测”数据不同于训练数据中非零列的数量。

还不知道，最好的地方是解决这个问题。

我也担心，由于@bryan-woods 报告的内容，稀疏矩阵处理存在一个基本问题：假设，我们在训练和测试中都有 x 个零列，但具有不同的索引 => 会有没有错误，因为“feature_names(self)”为两个集合返回相同的特征列表，但由于训练和测试之间的非零列索引不匹配，预测可能是错误的。

有没有人研究过这个问题？ 有没有人至少开发了一个单元测试，我们可以用它来开发？

我还没有研究过，但我认为@dmcgarry上面的例子可以用作单元测试的开始，

import xgboost as xgb
import numpy as np
import scipy.sparse


def test_xgbclassifier_sklearn_sparse():
    np.random.seed(10)
    X = scipy.sparse.rand(100,10).tocsr()
    test = scipy.sparse.rand(10, 500).tocsr()
    y = np.random.randint(2,size=100)

    clf = xgb.XGBClassifier()
    clf.fit(X,y)
    pred = clf.predict_proba(test)

我在我的 repo 分支中创建了几个新的稀疏数组测试。 对于那些有兴趣的人：
https://github.com/bryan-woods/xgboost/blob/sparse_test/tests/python/test_scipy_sparse.py

要从结帐的根目录运行测试：
python -m 鼻子测试/python/test_scipy_sparse.py

您会注意到两个测试都失败了。 这至少将提供一个测试来开发。

我也遇到了这个问题，但在最终在 lib 中解决之前，我无法弄清楚什么是最好的修复方法。

移至https://github.com/dmlc/xgboost/issues/1583

您可以使用最大功能索引将功能添加到功能列表中，例如maxid:0

传递数据框为我解决了这个问题

我怎样才能恢复到 0.4 版？

pip install --upgrade xgboost==0.4a30

所有类型的稀疏矩阵都不适合我（我正在使用 tf-idf 数据）。 我不得不恢复到以前的版本。 谢谢你的提示！

仍然有问题的所有人：您正在使用的代码是否包含 #1606 中的修复程序？

是的，我已经安装了最新版本的 xgboost，但我仍然遇到这个问题。

这仍然存在并且很容易重现。 如果您使用足够大的数据集，则不太可能发生这种情况，但如果您将其包装在网格搜索对象中，则几乎肯定会发生在 cv 拆分中，其中 train/cv 测试集中的可用特征不同。

老实说，我真的不明白为什么 DMatrix 会忽略 scipy 稀疏矩阵提供的形状提示。 它应该根据该信息设置大小，而不是计算它。

我正在使用 Xgboost Python 本机 API (0.6) 并且在从 LIBSVM [稀疏] 格式文件加载 DMatrix 时遇到相同的错误，如果任何行包含定义了最后一列。 我的解决方法是在第一行定义一个虚拟列:(

train_fv_file = 'train_fv_eval.svm'
dtrain = xgb.DMatrix(train_fv_file, feature_names=feature_vector_labels, feature_types=feature_vector_types)

如果它很容易重现，有人愿意提供一个可重现的例子吗？ 最好没有 sklearn 层（以隔离可能的原因）。

@gabrielspmoreira ：我明白您关于从最后几列完全稀疏的 LIBSVM 文件加载的观点...... DMatrix 构造方法也将从num_col提示中受益。

In [42]: matrix = xgboost.DMatrix(scipy.sparse.csr_matrix([[0, 2, 3, 0], [0, 2, 2, 0], [1, 0, 5, 0], [0, 1, 0, 0]], shape=(4,4)))
In [43]: matrix.num_col()
Out[43]: 3L

任何时候在行/列的子样本上创建新的 DMatrix 时，都有可能发生这种情况（即使我们明确告诉 DMatrix 有多少列，列数也会减少）。 对于较小的数据集或非常非常稀疏的列，这种情况经常发生，因为子集更有可能全为零。

一旦在训练/测试集之间发生这种情况，模型就无法评估测试集，因为它期望不同数量的特征并吐出 ValueError。

我试图找到一个测试，它在 xgboost 核心和 sklearn-wrapper 中有效/无效，因为我确信正在发生的事情，但我不知道它在哪里发生。

@l3link ：您的代码似乎已过时。 这是我得到的：

In [2]: import scipy
   ...: import xgboost
   ...: matrix = xgboost.DMatrix(scipy.sparse.csr_matrix([[0, 2, 3, 0], [0, 2, 2, 0], [1, 0, 5, 0], [0, 1, 0, 0]], shape=(4,4)))
   ...: matrix.num_col()
   ...:
Out[2]: 4L

In [3]: matrix._init_from_csr??
Signature: matrix._init_from_csr(csr)
Source:
    def _init_from_csr(self, csr):
        """
        Initialize data from a CSR matrix.
        """
        if len(csr.indices) != len(csr.data):
            raise ValueError('length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data)))
        self.handle = ctypes.c_void_p()
        _check_call(_LIB.XGDMatrixCreateFromCSREx(c_array(ctypes.c_size_t, csr.indptr),
                                                  c_array(ctypes.c_uint, csr.indices),
                                                  c_array(ctypes.c_float, csr.data),
                                                  len(csr.indptr), len(csr.data),
                                                  csr.shape[1],
                                                  ctypes.byref(self.handle)))
File:      c:\anaconda2\lib\site-packages\xgboost-0.6-py2.7.egg\xgboost\core.py
Type:      instancemethod

呵呵，

In [64]: xgboost.__version__ Out[64]: '0.6'

Signature: matrix._init_from_csr(csr) Source: def _init_from_csr(self, csr): """ Initialize data from a CSR matrix. """ if len(csr.indices) != len(csr.data): raise ValueError('length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data))) self.handle = ctypes.c_void_p() _check_call(_LIB.XGDMatrixCreateFromCSR(c_array(ctypes.c_ulong, csr.indptr), c_array(ctypes.c_uint, csr.indices), c_array(ctypes.c_float, csr.data), len(csr.indptr), len(csr.data), ctypes.byref(self.handle))) File: ~/anaconda/lib/python2.7/site-packages/xgboost/core.py Type: instancemethod

我的 .6 版本有 XGDMatrixCreateFromCSR 而不是 XGDMatrixCreateFromCSREx 指令，这似乎很奇怪，这不符合形状。
osx 分布是否可能不同？

我也担心，由于@bryan-woods 报告的内容，稀疏矩阵处理存在一个基本问题：假设，我们在训练和测试中都有 x 个零列，但具有不同的索引 => 会有没有错误，因为“feature_names(self)”为两个集合返回相同的特征列表，但由于训练和测试之间的非零列索引不匹配，预测可能是错误的。

有人可以回答这个问题吗？ 我恢复到 0.4 版本，现在它似乎可以工作，但我担心它是否可以正常工作，因为我仍在使用非常稀疏的矩阵。

@l3link没什么奇怪的：版本号（或 pypi 包）有时很长时间没有更新。 例如，截至今天的https://github.com/dmlc/xgboost/blob/master/python-package/xgboost/VERSION文件最后一次更改是在 7 月 29 日，最后一次 pypi 包https://pypi.python。 org/pypi/xgboost/日期为 8 月 9 日。 虽然修复程序是在 9 月 23 日 #1606 提交的。 请查看github的最新代码。

我在使用熊猫DataFrame （非稀疏表示）时遇到了这个问题。
我通过df.as_matrix()将它转换为numpy ndarray df.as_matrix() ，并且我摆脱了错误。

将数据帧转换为数组后，我也摆脱了这个错误。

以与训练集相同的顺序对测试集中的列重新排序为我解决了这个问题。
我使用了 Pandas 数据框。 没有这个，使用.as_matrix()会抛出同样的问题。

我做了：

test = test[train.columns]

我尝试了@warpuv解决方案，它奏效了。 我的数据很大，我无法将它们加载到内存以重新排序列。

将训练/测试 csr 矩阵转换为 csc 对我有用

Xtrain = scipy.sparse.csc_matrix(Xtrain)

转换为csc_matrix有效，在0.6a2 ：

    X_train = scipy.sparse.csc_matrix(X_train)
    X_test = scipy.sparse.csc_matrix(X_test)

    xgb_train = xgb.DMatrix(X_train, label=y_train)
    xgb_test = xgb.DMatrix(X_test, label=y_test)

type(X_train) <class 'scipy.sparse.csr.csr_matrix'>
type(X_test) <class 'scipy.sparse.csr.csr_matrix'>
type(X_train) <class 'scipy.sparse.csc.csc_matrix'>
type(X_test) <class 'scipy.sparse.csc.csc_matrix'>
type(xgb_train) <class 'xgboost.core.DMatrix'>
type(xgb_test) <class 'xgboost.core.DMatrix'>

我的原始稀疏矩阵是 sklearn tf-idf 矢量化器的输出，格式为csr_matrix 。

有什么解决办法吗？

刚刚在python3中构建了最新版本（0.7.post3），我可以确认这个问题仍然存在。 在调整上面的@dmcgarry示例后，我仍然看到csr_matrix和csc_matrix 。

import xgboost as xgb
import numpy as np
from scipy import sparse

np.random.seed(10)

X_csr = sparse.rand(100, 10).tocsr()
test_csr = sparse.rand(10, 500).tocsr()

X_csc = sparse.rand(100, 10).tocsc()
test_csc = sparse.rand(10, 500).tocsc()

y = np.random.randint(2, size=100)

clf_csr = xgb.XGBClassifier()
clf_csr.fit(X_csr, y)

clf_csc = xgb.XGBClassifier()
clf_csc.fit(X_csc, y)

# Try with csr
try:
    pred = clf_csr.predict_proba(test_csr)
    print("Works when csr with version %s" %xgb.__version__)
except ValueError:
    print("Broken when csr with version %s" %xgb.__version__)

try:
    test_csr[0,(test_csr.shape[1]-1)] = 1.0
    pred = clf_csr.predict_proba(test_csr)
    print("Works when adding non-zero entries to last column with version %s" %xgb.__version__)
except:
    print("Still broken when adding non-zero entries to last column with version %s" %xgb.__version__)

# Try with csc
try:
    pred = clf_csc.predict_proba(test_csc)
    print("Works when csc with version %s" %xgb.__version__)
except ValueError:
    print("Broken when csc with version %s" %xgb.__version__)

try:
    test_csc[0,(test_csc.shape[1]-1)] = 1.0
    pred = clf_csc.predict_proba(test_csc)
    print("Works when adding non-zero entries to last column with version %s" %xgb.__version__)
except:
    print("Still broken when adding non-zero entries to last column with version %s" %xgb.__version__)

上面的代码产生了以下输出：

Broken when csr with version 0.7
Still broken when adding non-zero entries to last column with version 0.7
Broken when csc with version 0.7
Still broken when adding non-zero entries to last column with version 0.7

请帮忙

为什么这个问题被关闭了？

我最近两次遇到这个问题。 在一种情况下，我只是将输入数据帧更改为数组并且它可以工作。 对于第二个，我必须使用 test_df = test_df[train_df.columns] 重新对齐测试数据框的列名。 在这两种情况下， train_df 和 test_df 具有完全相同的列名。

我想我不明白你的评论@CathyQian ，那些train_df / test_df稀疏吗？ 另外，当您遇到这些问题时，您运行的是哪个版本的 xgboost？

@CathyQian xgboost 依赖于列的 _order_，这与此问题无关。

@ewellinger WRT 您的示例：在具有 10 个特征的数据上训练的模型不应接受具有 500 个特征的数据进行预测，因此会引发错误。 此外，从所有矩阵创建 DMatrices 并检查它们的 num_col 和 num_row 会产生预期的结果。

“稀疏问题”的现状是：

• 从 CSR 创建 DMatrix 及其在模型中的使用应该可以正常工作。 该问题已关闭，因为这是本问题的主题。
• 从 CSC 创建 DMatrix 会生成具有正确尺寸的对象，但当最后一行完全稀疏时，它可能会在训练或预测期间给出错误的结果 #2630。 我还没有时间正确修复那部分。
• 尚未实现在将 libsvm 数据加载到 DMatrix 时指定预定义列数的参数。 欢迎志愿者贡献。

@warpuv对我

有同样的错误，密集的矩阵。 （来自最新 anaconda 的 xgboost v.0.6。）
当我对训练样本的不同特征子集运行多重回归时发生错误。
每次在拟合下一个回归之前创建新的模型实例都解决了这个问题。

• 尚未实现在将 libsvm 数据加载到 DMatrix 时指定预定义列数的参数。 欢迎志愿者贡献。

从 0.8 开始，这仍然不存在，对吗？

从 CSC 创建 DMatrix 会生成具有正确尺寸的对象，但当最后一行完全稀疏时，它可能会在训练或预测期间给出错误的结果 #2630。 我还没有时间正确修复那部分。

@khatilov #3553 修复了这个问题。

尚未实现在将 libsvm 数据加载到 DMatrix 时指定预定义列数的参数。 欢迎志愿者贡献。

@MonsieurWave对于此功能，对 dmlc-core 的小型拉取请求应该可以解决问题。 让我看看。

@hcho3 非常感谢。

现在，我通过让 libsvm 的第一行不那么稀疏来规避这个问题，即：甚至保存值为 0 的列。