Hendrik/xgboost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change uint64_t to ulong, to make mac happy, this is final change

Browse Source
This commit is contained in:
tqchen 2014-08-26 20:10:07 -07:00
parent d00f27dc6b
commit 4787108b5f
4 changed files with 56 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
R-package/src/xgboost_R.cpp
View File

@ -119,7 +119,7 @@ extern "C" {
} }
} }
SEXP XGDMatrixGetInfo_R(SEXP handle, SEXP field) { SEXP XGDMatrixGetInfo_R(SEXP handle, SEXP field) {
uint64_t olen; bst_ulong olen;
const float *res = XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle), const float *res = XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle),
CHAR(asChar(field)), &olen); CHAR(asChar(field)), &olen);
SEXP ret = PROTECT(allocVector(REALSXP, olen)); SEXP ret = PROTECT(allocVector(REALSXP, olen));
@ -188,7 +188,7 @@ extern "C" {
&vec_dmats[0], &vec_sptr[0], len)); &vec_dmats[0], &vec_sptr[0], len));
} }
SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP output_margin) { SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP output_margin) {
uint64_t olen; bst_ulong olen;
const float *res = XGBoosterPredict(R_ExternalPtrAddr(handle), const float *res = XGBoosterPredict(R_ExternalPtrAddr(handle),
R_ExternalPtrAddr(dmat), R_ExternalPtrAddr(dmat),
asInteger(output_margin), asInteger(output_margin),
@ -207,7 +207,7 @@ extern "C" {
XGBoosterSaveModel(R_ExternalPtrAddr(handle), CHAR(asChar(fname))); XGBoosterSaveModel(R_ExternalPtrAddr(handle), CHAR(asChar(fname)));
} }
void XGBoosterDumpModel_R(SEXP handle, SEXP fname, SEXP fmap) { void XGBoosterDumpModel_R(SEXP handle, SEXP fname, SEXP fmap) {
uint64_t olen; bst_ulong olen;
const char **res = XGBoosterDumpModel(R_ExternalPtrAddr(handle), const char **res = XGBoosterDumpModel(R_ExternalPtrAddr(handle),
CHAR(asChar(fmap)), CHAR(asChar(fmap)),
&olen); &olen);

6
wrapper/xgboost_R.cpp
View File

@ -119,7 +119,7 @@ extern "C" {
} }
} }
SEXP XGDMatrixGetInfo_R(SEXP handle, SEXP field) { SEXP XGDMatrixGetInfo_R(SEXP handle, SEXP field) {
uint64_t olen; bst_ulong olen;
const float *res = XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle), const float *res = XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle),
CHAR(asChar(field)), &olen); CHAR(asChar(field)), &olen);
SEXP ret = PROTECT(allocVector(REALSXP, olen)); SEXP ret = PROTECT(allocVector(REALSXP, olen));
@ -188,7 +188,7 @@ extern "C" {
&vec_dmats[0], &vec_sptr[0], len)); &vec_dmats[0], &vec_sptr[0], len));
} }
SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP output_margin) { SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP output_margin) {
uint64_t olen; bst_ulong olen;
const float *res = XGBoosterPredict(R_ExternalPtrAddr(handle), const float *res = XGBoosterPredict(R_ExternalPtrAddr(handle),
R_ExternalPtrAddr(dmat), R_ExternalPtrAddr(dmat),
asInteger(output_margin), asInteger(output_margin),
@ -207,7 +207,7 @@ extern "C" {
XGBoosterSaveModel(R_ExternalPtrAddr(handle), CHAR(asChar(fname))); XGBoosterSaveModel(R_ExternalPtrAddr(handle), CHAR(asChar(fname)));
} }
void XGBoosterDumpModel_R(SEXP handle, SEXP fname, SEXP fmap) { void XGBoosterDumpModel_R(SEXP handle, SEXP fname, SEXP fmap) {
uint64_t olen; bst_ulong olen;
const char **res = XGBoosterDumpModel(R_ExternalPtrAddr(handle), const char **res = XGBoosterDumpModel(R_ExternalPtrAddr(handle),
CHAR(asChar(fmap)), CHAR(asChar(fmap)),
&olen); &olen);

62
wrapper/xgboost_wrapper.cpp
View File

@ -23,14 +23,14 @@ class Booster: public learner::BoostLearner<FMatrixS> {
this->init_model = false; this->init_model = false;
this->SetCacheData(mats); this->SetCacheData(mats);
} }
const float *Pred(const DataMatrix &dmat, int output_margin, uint64_t *len) { const float *Pred(const DataMatrix &dmat, int output_margin, bst_ulong *len) {
this->CheckInitModel(); this->CheckInitModel();
this->Predict(dmat, output_margin, &this->preds_); this->Predict(dmat, output_margin, &this->preds_);
*len = this->preds_.size(); *len = this->preds_.size();
return &this->preds_[0]; return &this->preds_[0];
} }
inline void BoostOneIter(const DataMatrix &train, inline void BoostOneIter(const DataMatrix &train,
float *grad, float *hess, uint64_t len) { float *grad, float *hess, bst_ulong len) {
this->gpair_.resize(len); this->gpair_.resize(len);
const bst_omp_uint ndata = static_cast<bst_omp_uint>(len); const bst_omp_uint ndata = static_cast<bst_omp_uint>(len);
#pragma omp parallel for schedule(static) #pragma omp parallel for schedule(static)
@ -48,7 +48,7 @@ class Booster: public learner::BoostLearner<FMatrixS> {
learner::BoostLearner<FMatrixS>::LoadModel(fname); learner::BoostLearner<FMatrixS>::LoadModel(fname);
this->init_model = true; this->init_model = true;
} }
inline const char** GetModelDump(const utils::FeatMap& fmap, bool with_stats, uint64_t *len) { inline const char** GetModelDump(const utils::FeatMap& fmap, bool with_stats, bst_ulong *len) {
model_dump = this->DumpModel(fmap, with_stats); model_dump = this->DumpModel(fmap, with_stats);
model_dump_cptr.resize(model_dump.size()); model_dump_cptr.resize(model_dump.size());
for (size_t i = 0; i < model_dump.size(); ++i) { for (size_t i = 0; i < model_dump.size(); ++i) {
@ -76,37 +76,37 @@ extern "C"{
void* XGDMatrixCreateFromFile(const char *fname, int silent) { void* XGDMatrixCreateFromFile(const char *fname, int silent) {
return LoadDataMatrix(fname, silent, false); return LoadDataMatrix(fname, silent, false);
} }
void* XGDMatrixCreateFromCSR(const uint64_t *indptr, void* XGDMatrixCreateFromCSR(const bst_ulong *indptr,
const unsigned *indices, const unsigned *indices,
const float *data, const float *data,
uint64_t nindptr, bst_ulong nindptr,
uint64_t nelem) { bst_ulong nelem) {
DMatrixSimple *p_mat = new DMatrixSimple(); DMatrixSimple *p_mat = new DMatrixSimple();
DMatrixSimple &mat = *p_mat; DMatrixSimple &mat = *p_mat;
mat.row_ptr_.resize(nindptr); mat.row_ptr_.resize(nindptr);
for (uint64_t i = 0; i < nindptr; ++i) { for (bst_ulong i = 0; i < nindptr; ++i) {
mat.row_ptr_[i] = static_cast<size_t>(indptr[i]); mat.row_ptr_[i] = static_cast<size_t>(indptr[i]);
} }
mat.row_data_.resize(nelem); mat.row_data_.resize(nelem);
for (uint64_t i = 0; i < nelem; ++i) { for (bst_ulong i = 0; i < nelem; ++i) {
mat.row_data_[i] = SparseBatch::Entry(indices[i], data[i]); mat.row_data_[i] = SparseBatch::Entry(indices[i], data[i]);
mat.info.info.num_col = std::max(mat.info.info.num_col, mat.info.info.num_col = std::max(mat.info.info.num_col,
static_cast<uint64_t>(indices[i]+1)); static_cast<size_t>(indices[i]+1));
} }
mat.info.info.num_row = nindptr - 1; mat.info.info.num_row = nindptr - 1;
return p_mat; return p_mat;
} }
void* XGDMatrixCreateFromMat(const float *data, void* XGDMatrixCreateFromMat(const float *data,
uint64_t nrow, bst_ulong nrow,
uint64_t ncol, bst_ulong ncol,
float missing) { float missing) {
DMatrixSimple *p_mat = new DMatrixSimple(); DMatrixSimple *p_mat = new DMatrixSimple();
DMatrixSimple &mat = *p_mat; DMatrixSimple &mat = *p_mat;
mat.info.info.num_row = nrow; mat.info.info.num_row = nrow;
mat.info.info.num_col = ncol; mat.info.info.num_col = ncol;
for (uint64_t i = 0; i < nrow; ++i, data += ncol) { for (bst_ulong i = 0; i < nrow; ++i, data += ncol) {
uint64_t nelem = 0; bst_ulong nelem = 0;
for (uint64_t j = 0; j < ncol; ++j) { for (bst_ulong j = 0; j < ncol; ++j) {
if (data[j] != missing) { if (data[j] != missing) {
mat.row_data_.push_back(SparseBatch::Entry(j, data[j])); mat.row_data_.push_back(SparseBatch::Entry(j, data[j]));
++nelem; ++nelem;
@ -118,7 +118,7 @@ extern "C"{
} }
void* XGDMatrixSliceDMatrix(void *handle, void* XGDMatrixSliceDMatrix(void *handle,
const int *idxset, const int *idxset,
uint64_t len) { bst_ulong len) {
DMatrixSimple tmp; DMatrixSimple tmp;
DataMatrix &dsrc = *static_cast<DataMatrix*>(handle); DataMatrix &dsrc = *static_cast<DataMatrix*>(handle);
if (dsrc.magic != DMatrixSimple::kMagic) { if (dsrc.magic != DMatrixSimple::kMagic) {
@ -139,10 +139,10 @@ extern "C"{
iter->BeforeFirst(); iter->BeforeFirst();
utils::Assert(iter->Next(), "slice"); utils::Assert(iter->Next(), "slice");
const SparseBatch &batch = iter->Value(); const SparseBatch &batch = iter->Value();
for (uint64_t i = 0; i < len; ++i) { for (bst_ulong i = 0; i < len; ++i) {
const int ridx = idxset[i]; const int ridx = idxset[i];
SparseBatch::Inst inst = batch[ridx]; SparseBatch::Inst inst = batch[ridx];
utils::Check(static_cast<uint64_t>(ridx) < batch.size, "slice index exceed number of rows"); utils::Check(static_cast<bst_ulong>(ridx) < batch.size, "slice index exceed number of rows");
ret.row_data_.resize(ret.row_data_.size() + inst.length); ret.row_data_.resize(ret.row_data_.size() + inst.length);
memcpy(&ret.row_data_[ret.row_ptr_.back()], inst.data, memcpy(&ret.row_data_[ret.row_ptr_.back()], inst.data,
sizeof(SparseBatch::Entry) * inst.length); sizeof(SparseBatch::Entry) * inst.length);
@ -165,46 +165,46 @@ extern "C"{
void XGDMatrixSaveBinary(void *handle, const char *fname, int silent) { void XGDMatrixSaveBinary(void *handle, const char *fname, int silent) {
SaveDataMatrix(*static_cast<DataMatrix*>(handle), fname, silent); SaveDataMatrix(*static_cast<DataMatrix*>(handle), fname, silent);
} }
void XGDMatrixSetFloatInfo(void *handle, const char *field, const float *info, uint64_t len) { void XGDMatrixSetFloatInfo(void *handle, const char *field, const float *info, bst_ulong len) {
std::vector<float> &vec = std::vector<float> &vec =
static_cast<DataMatrix*>(handle)->info.GetFloatInfo(field); static_cast<DataMatrix*>(handle)->info.GetFloatInfo(field);
vec.resize(len); vec.resize(len);
memcpy(&vec[0], info, sizeof(float) * len); memcpy(&vec[0], info, sizeof(float) * len);
} }
void XGDMatrixSetUIntInfo(void *handle, const char *field, const unsigned *info, uint64_t len) { void XGDMatrixSetUIntInfo(void *handle, const char *field, const unsigned *info, bst_ulong len) {
std::vector<unsigned> &vec = std::vector<unsigned> &vec =
static_cast<DataMatrix*>(handle)->info.GetUIntInfo(field); static_cast<DataMatrix*>(handle)->info.GetUIntInfo(field);
vec.resize(len); vec.resize(len);
memcpy(&vec[0], info, sizeof(unsigned) * len); memcpy(&vec[0], info, sizeof(unsigned) * len);
} }
void XGDMatrixSetGroup(void *handle, const unsigned *group, uint64_t len) { void XGDMatrixSetGroup(void *handle, const unsigned *group, bst_ulong len) {
DataMatrix *pmat = static_cast<DataMatrix*>(handle); DataMatrix *pmat = static_cast<DataMatrix*>(handle);
pmat->info.group_ptr.resize(len + 1); pmat->info.group_ptr.resize(len + 1);
pmat->info.group_ptr[0] = 0; pmat->info.group_ptr[0] = 0;
for (uint64_t i = 0; i < len; ++i) { for (bst_ulong i = 0; i < len; ++i) {
pmat->info.group_ptr[i+1] = pmat->info.group_ptr[i]+group[i]; pmat->info.group_ptr[i+1] = pmat->info.group_ptr[i]+group[i];
} }
} }
const float* XGDMatrixGetFloatInfo(const void *handle, const char *field, uint64_t* len) { const float* XGDMatrixGetFloatInfo(const void *handle, const char *field, bst_ulong* len) {
const std::vector<float> &vec = const std::vector<float> &vec =
static_cast<const DataMatrix*>(handle)->info.GetFloatInfo(field); static_cast<const DataMatrix*>(handle)->info.GetFloatInfo(field);
*len = vec.size(); *len = vec.size();
return &vec[0]; return &vec[0];
} }
const unsigned* XGDMatrixGetUIntInfo(const void *handle, const char *field, uint64_t* len) { const unsigned* XGDMatrixGetUIntInfo(const void *handle, const char *field, bst_ulong* len) {
const std::vector<unsigned> &vec = const std::vector<unsigned> &vec =
static_cast<const DataMatrix*>(handle)->info.GetUIntInfo(field); static_cast<const DataMatrix*>(handle)->info.GetUIntInfo(field);
*len = vec.size(); *len = vec.size();
return &vec[0]; return &vec[0];
} }
uint64_t XGDMatrixNumRow(const void *handle) { bst_ulong XGDMatrixNumRow(const void *handle) {
return static_cast<const DataMatrix*>(handle)->info.num_row(); return static_cast<const DataMatrix*>(handle)->info.num_row();
} }
// xgboost implementation // xgboost implementation
void *XGBoosterCreate(void *dmats[], uint64_t len) { void *XGBoosterCreate(void *dmats[], bst_ulong len) {
std::vector<DataMatrix*> mats; std::vector<DataMatrix*> mats;
for (uint64_t i = 0; i < len; ++i) { for (bst_ulong i = 0; i < len; ++i) {
DataMatrix *dtr = static_cast<DataMatrix*>(dmats[i]); DataMatrix *dtr = static_cast<DataMatrix*>(dmats[i]);
mats.push_back(dtr); mats.push_back(dtr);
} }
@ -224,7 +224,7 @@ extern "C"{
bst->UpdateOneIter(iter, *dtr); bst->UpdateOneIter(iter, *dtr);
} }
void XGBoosterBoostOneIter(void *handle, void *dtrain, void XGBoosterBoostOneIter(void *handle, void *dtrain,
float *grad, float *hess, uint64_t len) { float *grad, float *hess, bst_ulong len) {
Booster *bst = static_cast<Booster*>(handle); Booster *bst = static_cast<Booster*>(handle);
DataMatrix *dtr = static_cast<DataMatrix*>(dtrain); DataMatrix *dtr = static_cast<DataMatrix*>(dtrain);
bst->CheckInitModel(); bst->CheckInitModel();
@ -232,11 +232,11 @@ extern "C"{
bst->BoostOneIter(*dtr, grad, hess, len); bst->BoostOneIter(*dtr, grad, hess, len);
} }
const char* XGBoosterEvalOneIter(void *handle, int iter, void *dmats[], const char* XGBoosterEvalOneIter(void *handle, int iter, void *dmats[],
const char *evnames[], uint64_t len) { const char *evnames[], bst_ulong len) {
Booster *bst = static_cast<Booster*>(handle); Booster *bst = static_cast<Booster*>(handle);
std::vector<std::string> names; std::vector<std::string> names;
std::vector<const DataMatrix*> mats; std::vector<const DataMatrix*> mats;
for (uint64_t i = 0; i < len; ++i) { for (bst_ulong i = 0; i < len; ++i) {
mats.push_back(static_cast<DataMatrix*>(dmats[i])); mats.push_back(static_cast<DataMatrix*>(dmats[i]));
names.push_back(std::string(evnames[i])); names.push_back(std::string(evnames[i]));
} }
@ -244,7 +244,7 @@ extern "C"{
bst->eval_str = bst->EvalOneIter(iter, mats, names); bst->eval_str = bst->EvalOneIter(iter, mats, names);
return bst->eval_str.c_str(); return bst->eval_str.c_str();
} }
const float *XGBoosterPredict(void *handle, void *dmat, int output_margin, uint64_t *len) { const float *XGBoosterPredict(void *handle, void *dmat, int output_margin, bst_ulong *len) {
return static_cast<Booster*>(handle)->Pred(*static_cast<DataMatrix*>(dmat), output_margin, len); return static_cast<Booster*>(handle)->Pred(*static_cast<DataMatrix*>(dmat), output_margin, len);
} }
void XGBoosterLoadModel(void *handle, const char *fname) { void XGBoosterLoadModel(void *handle, const char *fname) {
@ -253,7 +253,7 @@ extern "C"{
void XGBoosterSaveModel(const void *handle, const char *fname) { void XGBoosterSaveModel(const void *handle, const char *fname) {
static_cast<const Booster*>(handle)->SaveModel(fname); static_cast<const Booster*>(handle)->SaveModel(fname);
} }
const char** XGBoosterDumpModel(void *handle, const char *fmap, uint64_t *len){ const char** XGBoosterDumpModel(void *handle, const char *fmap, bst_ulong *len){
utils::FeatMap featmap; utils::FeatMap featmap;
if (strlen(fmap) != 0) { if (strlen(fmap) != 0) {
featmap.LoadText(fmap); featmap.LoadText(fmap);

37
wrapper/xgboost_wrapper.h
View File

@ -7,8 +7,9 @@
* can be used to create wrapper of other languages * can be used to create wrapper of other languages
*/ */
#include <cstdio> #include <cstdio>
#include "../src/utils/utils.h"
#define XGB_DLL #define XGB_DLL
// manually define unsign long
typedef unsigned long bst_ulong;
extern "C" { extern "C" {
/*! /*!
@ -25,11 +26,11 @@ extern "C" {
* \param nelem number of nonzero elements in the matrix * \param nelem number of nonzero elements in the matrix
* \return created dmatrix * \return created dmatrix
*/ */
XGB_DLL void* XGDMatrixCreateFromCSR(const uint64_t *indptr, XGB_DLL void* XGDMatrixCreateFromCSR(const bst_ulong *indptr,
const unsigned *indices, const unsigned *indices,
const float *data, const float *data,
uint64_t nindptr, bst_ulong nindptr,
uint64_t nelem); bst_ulong nelem);
/*! /*!
* \brief create matrix content from dense matrix * \brief create matrix content from dense matrix
* \param data pointer to the data space * \param data pointer to the data space
@ -39,8 +40,8 @@ extern "C" {
* \return created dmatrix * \return created dmatrix
*/ */
XGB_DLL void* XGDMatrixCreateFromMat(const float *data, XGB_DLL void* XGDMatrixCreateFromMat(const float *data,
uint64_t nrow, bst_ulong nrow,
uint64_t ncol, bst_ulong ncol,
float missing); float missing);
/*! /*!
* \brief create a new dmatrix from sliced content of existing matrix * \brief create a new dmatrix from sliced content of existing matrix
@ -51,7 +52,7 @@ extern "C" {
*/ */
XGB_DLL void* XGDMatrixSliceDMatrix(void *handle, XGB_DLL void* XGDMatrixSliceDMatrix(void *handle,
const int *idxset, const int *idxset,
uint64_t len); bst_ulong len);
/*! /*!
* \brief free space in data matrix * \brief free space in data matrix
*/ */
@ -70,7 +71,7 @@ extern "C" {
* \param array pointer to float vector * \param array pointer to float vector
* \param len length of array * \param len length of array
*/ */
XGB_DLL void XGDMatrixSetFloatInfo(void *handle, const char *field, const float *array, uint64_t len); XGB_DLL void XGDMatrixSetFloatInfo(void *handle, const char *field, const float *array, bst_ulong len);
/*! /*!
* \brief set uint32 vector to a content in info * \brief set uint32 vector to a content in info
* \param handle a instance of data matrix * \param handle a instance of data matrix
@ -78,14 +79,14 @@ extern "C" {
* \param array pointer to float vector * \param array pointer to float vector
* \param len length of array * \param len length of array
*/ */
XGB_DLL void XGDMatrixSetUIntInfo(void *handle, const char *field, const unsigned *array, uint64_t len); XGB_DLL void XGDMatrixSetUIntInfo(void *handle, const char *field, const unsigned *array, bst_ulong len);
/*! /*!
* \brief set label of the training matrix * \brief set label of the training matrix
* \param handle a instance of data matrix * \param handle a instance of data matrix
* \param group pointer to group size * \param group pointer to group size
* \param len length of array * \param len length of array
*/ */
XGB_DLL void XGDMatrixSetGroup(void *handle, const unsigned *group, uint64_t len); XGB_DLL void XGDMatrixSetGroup(void *handle, const unsigned *group, bst_ulong len);
/*! /*!
* \brief get float info vector from matrix * \brief get float info vector from matrix
* \param handle a instance of data matrix * \param handle a instance of data matrix
@ -93,7 +94,7 @@ extern "C" {
* \param out_len used to set result length * \param out_len used to set result length
* \return pointer to the result * \return pointer to the result
*/ */
XGB_DLL const float* XGDMatrixGetFloatInfo(const void *handle, const char *field, uint64_t* out_len); XGB_DLL const float* XGDMatrixGetFloatInfo(const void *handle, const char *field, bst_ulong* out_len);
/*! /*!
* \brief get uint32 info vector from matrix * \brief get uint32 info vector from matrix
* \param handle a instance of data matrix * \param handle a instance of data matrix
@ -101,18 +102,18 @@ extern "C" {
* \param out_len used to set result length * \param out_len used to set result length
* \return pointer to the result * \return pointer to the result
*/ */
XGB_DLL const unsigned* XGDMatrixGetUIntInfo(const void *handle, const char *field, uint64_t* out_len); XGB_DLL const unsigned* XGDMatrixGetUIntInfo(const void *handle, const char *field, bst_ulong* out_len);
/*! /*!
* \brief return number of rows * \brief return number of rows
*/ */
XGB_DLL uint64_t XGDMatrixNumRow(const void *handle); XGB_DLL bst_ulong XGDMatrixNumRow(const void *handle);
// --- start XGBoost class // --- start XGBoost class
/*! /*!
* \brief create xgboost learner * \brief create xgboost learner
* \param dmats matrices that are set to be cached * \param dmats matrices that are set to be cached
* \param len length of dmats * \param len length of dmats
*/ */
XGB_DLL void *XGBoosterCreate(void* dmats[], uint64_t len); XGB_DLL void *XGBoosterCreate(void* dmats[], bst_ulong len);
/*! /*!
* \brief free obj in handle * \brief free obj in handle
* \param handle handle to be freed * \param handle handle to be freed
@ -142,7 +143,7 @@ extern "C" {
* \param len length of grad/hess array * \param len length of grad/hess array
*/ */
XGB_DLL void XGBoosterBoostOneIter(void *handle, void *dtrain, XGB_DLL void XGBoosterBoostOneIter(void *handle, void *dtrain,
float *grad, float *hess, uint64_t len); float *grad, float *hess, bst_ulong len);
/*! /*!
* \brief get evaluation statistics for xgboost * \brief get evaluation statistics for xgboost
* \param handle handle * \param handle handle
@ -153,7 +154,7 @@ extern "C" {
* \return the string containing evaluation stati * \return the string containing evaluation stati
*/ */
XGB_DLL const char *XGBoosterEvalOneIter(void *handle, int iter, void *dmats[], XGB_DLL const char *XGBoosterEvalOneIter(void *handle, int iter, void *dmats[],
const char *evnames[], uint64_t len); const char *evnames[], bst_ulong len);
/*! /*!
* \brief make prediction based on dmat * \brief make prediction based on dmat
* \param handle handle * \param handle handle
@ -161,7 +162,7 @@ extern "C" {
* \param output_margin whether only output raw margin value * \param output_margin whether only output raw margin value
* \param len used to store length of returning result * \param len used to store length of returning result
*/ */
XGB_DLL const float *XGBoosterPredict(void *handle, void *dmat, int output_margin, uint64_t *len); XGB_DLL const float *XGBoosterPredict(void *handle, void *dmat, int output_margin, bst_ulong *len);
/*! /*!
* \brief load model from existing file * \brief load model from existing file
* \param handle handle * \param handle handle
@ -182,6 +183,6 @@ extern "C" {
* \return char *data[], representing dump of each model * \return char *data[], representing dump of each model
*/ */
XGB_DLL const char **XGBoosterDumpModel(void *handle, const char *fmap, XGB_DLL const char **XGBoosterDumpModel(void *handle, const char *fmap,
uint64_t *out_len); bst_ulong *out_len);
}; };
#endif // XGBOOST_WRAPPER_H_ #endif // XGBOOST_WRAPPER_H_