Xgboost: फीचर_नाम बेमेल पायथन में विरल मैट्रिसेस का उपयोग करते समय

ऐसा लगता है कि यह तभी काम करता है जब विरल मैट्रिक सीएससी हो। यह पहले के संस्करणों की तरह सीएसआर या सीओओ मैट्रिसेस के लिए काम नहीं करता है।

क्या यह एक यादृच्छिक समस्या नहीं होती है जब सबसे दाएं कॉलम सभी 0 या 1 होते हैं? शायद #1091 और #1221 के समान।

@sinhrks : मेरे लिए, यह "यादृच्छिक" नहीं है। मैं अक्सर अत्यधिक विरल डेटा पर XGBoost को प्रशिक्षित करता हूं (और यह बहुत बढ़िया है! यह सामान्य रूप से अन्य सभी मॉडलों को पीछे छोड़ देता है, और काफी व्यापक अंतर से)।

फिर, एक बार जब मुझे उत्पादन में प्रशिक्षित मॉडल मिल जाता है, तो निश्चित रूप से, मैं आने वाले डेटा के एक नए टुकड़े पर भविष्यवाणियां करना चाहता हूं। वह डेटा, निश्चित रूप से, विरल होने की अत्यधिक संभावना है और अंतिम कॉलम होने वाले किसी भी कॉलम के लिए कोई मूल्य नहीं है। इसलिए XGBoost अब मेरे लिए बार-बार टूटता है, और मैंने खुद को अन्य (कम सटीक) मॉडल पर स्विच करते हुए पाया है, सिर्फ इसलिए कि उन्हें विरल डेटा के लिए बेहतर समर्थन मिला है।

क्या किसी को पता है कि यह त्रुटि अब क्यों उत्पन्न होती है और इसे कैसे संबोधित किया जाए? यह मेरे लिए एक दर्द की बात है क्योंकि मेरी मौजूदा स्क्रिप्ट विफल हो रही हैं।

मैं xgboost एक स्केलेर पाइपलाइन के हिस्से के रूप में एक कोशिश दे रहा हूँ और उसी मुद्दे में भाग गया। क्या इसके तय होने तक कोई वर्कअराउंड है?

हां, जब आप भविष्यवाणी कहते हैं, तो विरल सरणी के toarray() फ़ंक्शन का उपयोग करें। यह स्मृति के साथ बहुत अक्षम है, लेकिन छोटे स्लाइस के साथ काम करने योग्य है।

मेरे आईफोन से भेजा गया

२६ अगस्त २०१६ को रात १०:४४ बजे पेड्रो रोड्रिग्ज नोटिफिकेशन @github.com ने लिखा:

मैं xgboost एक स्केलेर पाइपलाइन के हिस्से के रूप में एक कोशिश दे रहा हूँ और उसी मुद्दे में भाग गया। क्या इसके तय होने तक कोई वर्कअराउंड है?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे 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)

@ ब्रायन-वुड्स मैं tocsc साथ एक बेहतर काम खोजने में सक्षम था। शायद कुछ प्रदर्शन दंड है लेकिन यह घने मैट्रिक्स बनाने जितना बुरा नहीं है।

xgboost के काम करने से ठीक पहले इसे मेरी स्केलेर पाइपलाइन में शामिल करना

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 {}

न तो CSC प्रारूप और न ही अंतिम कॉलम में गैर-शून्य प्रविष्टियाँ जोड़ने से xgboost के नवीनतम संस्करण में समस्या का समाधान होता है। संस्करण 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

यहाँ वही मुद्दा, पिछली रिलीज़ में कुछ निश्चित रूप से टूट गया। समान डेटासेट और प्रोसेसिंग के साथ पहले यह समस्या नहीं थी। मैं गलत हो सकता हूं, लेकिन ऐसा लगता है कि वर्तमान में स्केलेर एपीआई का उपयोग करके पायथन में विरल सीएसआर सरणियों के साथ कोई इकाई परीक्षण नहीं है। क्या उपरोक्त @dmcgarry उदाहरण को tests/python/tests_with_sklearn.py जोड़ना संभव होगा?

मैंने सीएसआर विरल सरणियों के साथ .toarray() का उपयोग करके इसके आसपास काम करने की कोशिश की, लेकिन कुछ गंभीर रूप से टूटा हुआ है। यदि मैं एक सहेजे गए मॉडल को लोड करता हूं और .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 विरल मैट्रिसेस के लिए कोई नहीं है, और क्योंकि self.num_col() केवल गैर-शून्य कॉल्स की मात्रा देता है, जैसे ही "टू-बी- पूर्वानुमानित" डेटा प्रशिक्षण डेटा में गैर-शून्य स्तंभों की मात्रा से भिन्न होता है।

पता नहीं अभी तक, जहां इसे ठीक करने के लिए सबसे अच्छी जगह है।

मुझे यह भी डर है कि स्पैस मैट्रिक्स हैंडलिंग के साथ एक मौलिक समस्या है, क्योंकि @ ब्रायन-वुड्स ने जो रिपोर्ट किया है: मान लीजिए, हमारे पास ट्रेन और परीक्षण दोनों में 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)

मैंने रेपो के अपने कांटे में कुछ नए विरल सरणी परीक्षण बनाए। रुचि रखने वालों के लिए:
https://github.com/bryan-woods/xgboost/blob/sparse_test/tests/python/test_scipy_sparse.py

चेकआउट की मूल निर्देशिका से परीक्षण चलाने के लिए:
अजगर-एम नाक परीक्षण/अजगर/test_scipy_sparse.py

आप देखेंगे कि दोनों परीक्षण विफल हो जाते हैं। यह कम से कम के खिलाफ विकसित करने के लिए एक परीक्षण प्रदान करेगा।

मैं भी इस समस्या का सामना कर रहा हूं, लेकिन मैं यह पता लगाने में सक्षम नहीं हूं कि इसे ठीक करने का सबसे अच्छा तरीका क्या है जब तक कि इसे अंततः lib में हल नहीं किया जाता है।

https://github.com/dmlc/xgboost/issues/1583 पर

आप अधिकतम फीचर इंडेक्स के साथ अपनी फीचर सूची में एक फीचर जोड़ सकते हैं, जैसे कि मैक्सिड: 0

डेटाफ़्रेम पास करने से मेरे लिए समस्या हल हो गई

मैं संस्करण 0.4 पर कैसे वापस आ सकता हूं?

पाइप इंस्टाल --अपग्रेड xgboost==0.4a30

सभी प्रकार के विरल मैट्रिसेस ने मेरे लिए काम नहीं किया (मैं tf-idf डेटा के साथ काम कर रहा हूँ)। मुझे पिछले संस्करण पर वापस जाना पड़ा। पारितोषिक के लिए धन्यवाद!

आप सभी जिन्हें अभी भी समस्या हो रही है: क्या आप जिस कोड का उपयोग कर रहे हैं, उसमें #1606 में सुधार शामिल हैं?

हां, मैंने xgboost का अंतिम संस्करण स्थापित किया है और मुझे अभी भी यह समस्या आ रही है।

यह अभी भी मौजूद है और आसानी से प्रतिलिपि प्रस्तुत करने योग्य है। यदि आप एक बड़े पर्याप्त डेटा सेट का उपयोग करते हैं तो ऐसा होने की संभावना कम है, लेकिन यदि आप इसे ग्रिड सर्च ऑब्जेक्ट में लपेट रहे हैं, तो यह लगभग निश्चित रूप से सीवी स्प्लिट के भीतर होता है जहां ट्रेन/सीवी टेस्ट सेट में उपलब्ध सुविधाएं भिन्न होती हैं।

ईमानदारी से, मैं वास्तव में समझ नहीं पा रहा हूं कि डीमैट्रिक्स आकार संकेत को अनदेखा क्यों करता है जो कि scipy sparse matrices द्वारा प्रदान किया जाता है। इसे गणना करने के बजाय उस जानकारी के आधार पर आकार निर्धारित करना चाहिए।

मैं Xgboost Python मूल API (0.6) का उपयोग कर रहा हूं और LIBSVM [sparse] प्रारूप फ़ाइल से DMatrix लोड करते समय मुझे वही त्रुटि मिली है, यदि किसी भी पंक्ति में अंतिम कॉलम परिभाषित है। मेरा समाधान पहली पंक्ति में एक डमी कॉलम को परिभाषित करना था :(

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

यदि पुनरुत्पादन करना इतना आसान है, तो क्या कोई प्रतिलिपि प्रस्तुत करने योग्य उदाहरण प्रदान करने की परवाह करता है? अधिमानतः, स्केलेर परत के बिना (एक संभावित कारण को अलग करने के लिए)।

@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

जब भी पंक्तियों/स्तंभों के उप-नमूने पर एक नया डीमैट्रिक्स बनाया जाता है, तो ऐसा होने की संभावना होती है (स्तंभों की संख्या कम हो जाती है, भले ही हमने डीमैट्रिक्स को स्पष्ट रूप से बताया कि कितने कॉलम हैं)। यह अक्सर छोटे डेटा सेट या बहुत ही विरल स्तंभों के लिए होता है क्योंकि यह अधिक संभावना है कि एक सबसेट सभी शून्य होगा।

एक बार जब यह ट्रेन/परीक्षण सेट के बीच होता है, तो मॉडल परीक्षण सेट का मूल्यांकन नहीं कर सकता क्योंकि यह विभिन्न सुविधाओं की अपेक्षा करता है और एक ValueError थूकता है।

मैं एक परीक्षण खोजने की कोशिश कर रहा हूं जहां यह xgboost core और 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 संस्करण में XGDMatrixCreateFromCSRex निर्देशों के बजाय XGDMatrixCreateFromCSR है, जो आकार में नहीं आता है।
क्या यह संभव है कि ओएसएक्स वितरण अलग हो?

मुझे यह भी डर है कि स्पैस मैट्रिक्स हैंडलिंग के साथ एक मौलिक समस्या है, क्योंकि @ ब्रायन-वुड्स ने जो रिपोर्ट किया है: मान लीजिए, हमारे पास ट्रेन और परीक्षण दोनों में x शून्य-कॉलम हैं, लेकिन विभिन्न सूचकांकों के साथ => होगा कोई त्रुटि न हो, क्योंकि "feature_names(self)" दोनों सेटों के लिए समान सुविधा सूची लौटाता है, लेकिन ट्रेन और परीक्षण के बीच गैर-शून्य कॉलम इंडेक्स से मेल नहीं खाने के कारण भविष्यवाणियां गलत हो सकती हैं।

क्या कोई कृपया इस प्रश्न का उत्तर दे सकता है? मैं 0.4 संस्करण पर वापस लौट आया और अब यह काम करने लगता है लेकिन मुझे डर है कि यह ठीक से काम कर रहा है क्योंकि मैं अभी भी वास्तव में स्पैस मैट्रिस का उपयोग कर रहा हूं।

@ l3link इसके बारे में कुछ भी विचित्र नहीं है: संस्करण संख्याएं (या पीपीआई पैकेज) कभी-कभी लंबे समय तक अपडेट नहीं होती हैं। उदाहरण के लिए, आज की स्थिति में https://github.com/dmlc/xgboost/blob/master/python-package/xgboost/VERSION फ़ाइल को पिछली बार 29 जुलाई को और अंतिम pypi पैकेज https://pypi.python को बदला गया था। org/pypi/xgboost/ दिनांक 9 अगस्त है। जबकि फिक्स 23 सितंबर #1606 को सबमिट किया गया था। कृपया जीथब से नवीनतम कोड देखें।

मुझे यह समस्या तब हुई जब मैंने पांडा DataFrame (गैर-विरल प्रतिनिधित्व) का उपयोग किया।
मैंने इसे numpy ndarray माध्यम से df.as_matrix() , और मुझे त्रुटि से छुटकारा मिल गया।

डेटाफ्रेम को ऐरे में बदलने के बाद मुझे भी इस त्रुटि से छुटकारा मिल गया।

टेस्ट-सेट में कॉलम को उसी क्रम में फिर से व्यवस्थित करना जैसे ट्रेन सेट ने मेरे लिए इसे तय किया था।
मैंने पंडों के डेटाफ्रेम का इस्तेमाल किया। इसके बिना, .as_matrix() का उपयोग करना उसी मुद्दे को फेंक रहा था।

मैंने किया:

test = test[train.columns]

मैंने @warpuv समाधान की कोशिश की और यह काम कर गया। मेरा डेटा बड़ा है, मैं कॉलम को पुन: व्यवस्थित करने के लिए उन्हें स्मृति में लोड नहीं कर सकता।

ट्रेन/परीक्षण सीएसआर मैट्रिसेस को सीएससी में परिवर्तित करना मेरे लिए कारगर रहा

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'>

मेरा मूल स्पैस मैट्रिक्स स्केलेर टीएफ-आईडीएफ वेक्टरिज़र का आउटपुट 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 का निरीक्षण करने से अपेक्षित परिणाम मिलते हैं।

"दुर्लभ मुद्दों" की वर्तमान स्थिति है:

• सीएसआर से डीमैट्रिक्स का निर्माण और एक मॉडल में इसका उपयोग सही ढंग से काम करना चाहिए। इस मुद्दे को बंद कर दिया गया था क्योंकि यह इस मुद्दे का विषय था।
• सीएससी से डीमैट्रिक्स का निर्माण सही आयामों के साथ एक वस्तु का उत्पादन करता है, लेकिन यह प्रशिक्षण या भविष्यवाणी के दौरान गलत परिणाम दे सकता है जब अंतिम पंक्तियाँ पूरी तरह से विरल # 2630 होती हैं। मेरे पास अभी तक उस हिस्से को ठीक से ठीक करने का समय नहीं था।
• DMatrix में libsvm डेटा लोड करते समय कॉलम की पूर्वनिर्धारित संख्या निर्दिष्ट करने के लिए एक पैरामीटर अभी तक लागू नहीं किया गया था। योगदान करने के लिए स्वयंसेवकों का स्वागत है।

@warpuv यह मेरे लिए काम करता है, बहुत बहुत धन्यवाद।

घने मैट्रिसेस के साथ एक ही त्रुटि थी। (नवीनतम एनाकोंडा से xgboost v.0.6।)
त्रुटि तब हुई जब मैंने प्रशिक्षण नमूने के विभिन्न फीचर सबसेट पर कई प्रतिगमन चलाए।
अगले प्रतिगमन को फिट करने से पहले हर बार नया मॉडल उदाहरण बनाना समस्या को ठीक करता है।

• DMatrix में libsvm डेटा लोड करते समय कॉलम की पूर्वनिर्धारित संख्या निर्दिष्ट करने के लिए एक पैरामीटर अभी तक लागू नहीं किया गया था। योगदान करने के लिए स्वयंसेवकों का स्वागत है।

0.8 तक, यह अभी भी मौजूद नहीं है, है ना?

सीएससी से डीमैट्रिक्स का निर्माण सही आयामों के साथ एक वस्तु का उत्पादन करता है, लेकिन यह प्रशिक्षण या भविष्यवाणी के दौरान गलत परिणाम दे सकता है जब अंतिम पंक्तियाँ पूरी तरह से विरल # 2630 होती हैं। मेरे पास अभी तक उस हिस्से को ठीक से ठीक करने का समय नहीं था।

@खोटिलोव #3553 ने इस मुद्दे को ठीक किया।

DMatrix में libsvm डेटा लोड करते समय कॉलम की पूर्वनिर्धारित संख्या निर्दिष्ट करने के लिए एक पैरामीटर अभी तक लागू नहीं किया गया था। योगदान करने के लिए स्वयंसेवकों का स्वागत है।

@MonsieurWave इस सुविधा के लिए, dmlc-core के लिए एक छोटा पुल अनुरोध करना चाहिए। मुझे इसे देखने दो।

@ hcho3 बहुत बहुत धन्यवाद।

अभी के लिए, मैं अपने libsvm की पहली पंक्ति इतनी विरल नहीं होने से इस मुद्दे को दरकिनार करता हूं, अर्थात: मान 0 वाले कॉलम को भी सहेजना।