• Your recent searches
Alien-XGBoost
10 results

 view release on metacpan or  search on metacpan

xgboost/Makefile  view on Meta::CPAN 

ifeq ($(USE_OPENMP), 0)
	export NO_OPENMP = 1
endif
include $(DMLC_CORE)/make/dmlc.mk

# include the plugins
ifdef XGB_PLUGINS
include $(XGB_PLUGINS)
endif

# set compiler defaults for OSX versus *nix
# let people override either
OS := $(shell uname)
ifeq ($(OS), Darwin)
ifndef CC
export CC = $(if $(shell which clang), clang, gcc)
endif
ifndef CXX
export CXX = $(if $(shell which clang++), clang++, g++)
endif
else

xgboost/appveyor.yml  view on Meta::CPAN 

          configuration: Release
        - target: msvc
          ver: 2015
          generator: "Visual Studio 14 2015 Win64"
          configuration: Debug
        - target: msvc
          ver: 2015
          generator: "Visual Studio 14 2015 Win64"
          configuration: Release
        - target: mingw
          generator: "Unix Makefiles"
        - target: jvm

platform:
    - x64

install:
    - git submodule update --init --recursive
    # MinGW
    - set PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%
    - gcc -v

xgboost/demo/binary_classification/README.md  view on Meta::CPAN 

#### Continue from Existing Model
If you want to continue boosting from existing model, say 0002.model, use
```
../../xgboost mushroom.conf model_in=0002.model num_round=2 model_out=continue.model
```
xgboost will load from 0002.model continue boosting for 2 rounds, and save output to continue.model. However, beware that the training and evaluation data specified in mushroom.conf should not change when you use this function.
#### Use Multi-Threading
When you are working with a large dataset, you may want to take advantage of parallelism. If your compiler supports OpenMP, xgboost is naturally multi-threaded, to set number of parallel running add ```nthread``` parameter to you configuration.
Eg. ```nthread=10```

Set nthread to be the number of your real cpu (On Unix, this can be found using ```lscpu```)
Some systems will have ```Thread(s) per core = 2```, for example, a 4 core cpu with 8 threads, in such case set ```nthread=4``` and not 8.

xgboost/demo/regression/machine.data  view on Meta::CPAN 

ncr,v8565:ii,56,2000,6000,0,1,8,21,35
ncr,v8565:ii-e,56,2000,8000,0,1,8,24,41
ncr,v8575:ii,56,4000,8000,0,1,8,34,47
ncr,v8585:ii,56,4000,12000,0,1,8,42,62
ncr,v8595:ii,56,4000,16000,0,1,8,46,78
ncr,v8635,38,4000,8000,32,16,32,51,80
ncr,v8650,38,4000,8000,32,16,32,116,80
ncr,v8655,38,8000,16000,64,4,8,100,142
ncr,v8665,38,8000,24000,160,4,8,140,281
ncr,v8670,38,4000,16000,128,16,32,212,190
nixdorf,8890/30,200,1000,2000,0,1,2,25,21
nixdorf,8890/50,200,1000,4000,0,1,4,30,25
nixdorf,8890/70,200,2000,8000,64,1,5,41,67
perkin-elmer,3205,250,512,4000,0,1,7,25,24
perkin-elmer,3210,250,512,4000,0,4,7,50,24
perkin-elmer,3230,250,1000,16000,1,1,8,50,64
prime,50-2250,160,512,4000,2,1,5,30,25
prime,50-250-ii,160,512,2000,2,3,8,32,20
prime,50-550-ii,160,1000,4000,8,1,14,38,29
prime,50-750-ii,160,1000,8000,16,1,14,60,43
prime,50-850-ii,160,2000,8000,32,1,13,109,53
siemens,7.521,240,512,1000,8,1,3,6,19
siemens,7.531,240,512,2000,8,1,5,11,22

xgboost/demo/regression/machine.names  view on Meta::CPAN 


5. Number of Instances: 209 

6. Number of Attributes: 10 (6 predictive attributes, 2 non-predictive, 
                             1 goal field, and the linear regression's guess)

7. Attribute Information:
   1. vendor name: 30 
      (adviser, amdahl,apollo, basf, bti, burroughs, c.r.d, cambex, cdc, dec, 
       dg, formation, four-phase, gould, honeywell, hp, ibm, ipl, magnuson, 
       microdata, nas, ncr, nixdorf, perkin-elmer, prime, siemens, sperry, 
       sratus, wang)
   2. Model Name: many unique symbols
   3. MYCT: machine cycle time in nanoseconds (integer)
   4. MMIN: minimum main memory in kilobytes (integer)
   5. MMAX: maximum main memory in kilobytes (integer)
   6. CACH: cache memory in kilobytes (integer)
   7. CHMIN: minimum channels in units (integer)
   8. CHMAX: maximum channels in units (integer)
   9. PRP: published relative performance (integer)
  10. ERP: estimated relative performance from the original article (integer)

xgboost/dmlc-core/doc/Doxyfile  view on Meta::CPAN 


# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
# Note that relative paths are relative to the directory from which doxygen is
# run.

EXCLUDE                =

# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.

EXCLUDE_SYMLINKS       = NO

# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*

xgboost/dmlc-core/include/dmlc/timer.h  view on Meta::CPAN 

  return std::chrono::duration<double>(
      std::chrono::high_resolution_clock::now().time_since_epoch()).count();
  #elif defined __MACH__
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
  CHECK(clock_get_time(cclock, &mts) == 0) << "failed to get time";
  mach_port_deallocate(mach_task_self(), cclock);
  return static_cast<double>(mts.tv_sec) + static_cast<double>(mts.tv_nsec) * 1e-9;
  #else
  #if defined(__unix__) || defined(__linux__)
  timespec ts;
  CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0) << "failed to get time";
  return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) * 1e-9;
  #else
  return static_cast<double>(time(NULL));
  #endif
  #endif
}
}  // namespace dmlc
#endif  // DMLC_TIMER_H_

xgboost/doc/Doxyfile  view on Meta::CPAN 

# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
#
# Note that relative paths are relative to the directory from which doxygen is
# run.

EXCLUDE                =

# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
# The default value is: NO.

EXCLUDE_SYMLINKS       = NO

# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories.
#
# Note that the wildcards are matched against the file with absolute path, so to

xgboost/doc/jvm/xgboost4j-intro.md  view on Meta::CPAN 

requires new computation abstraction and native support (e.g. C++ for GPU computing).
They are also often [much more efficient](http://arxiv.org/abs/1603.02754).

The gap between the implementation fundamentals of the general data processing frameworks and the more specific machine learning libraries/systems prohibits the smooth connection between these two types of systems, thus brings unnecessary inconvenien...

We want best of both worlds, so we can use the data processing frameworks like Spark and Flink together with
the best distributed machine learning solutions.
To resolve the situation, we introduce the new-brewed [XGBoost4J](https://github.com/dmlc/xgboost/tree/master/jvm-packages),
<b>XGBoost</b> for <b>J</b>VM Platform. We aim to provide the clean Java/Scala APIs and the integration with the most popular data processing systems developed in JVM-based languages.

## Unix Philosophy in Machine Learning

XGBoost and XGBoost4J adopts Unix Philosophy.
XGBoost **does its best in one thing -- tree boosting** and is **being designed to work with other systems**.
We strongly believe that machine learning solution should not be restricted to certain language or certain platform.

Specifically, users will be able to use distributed XGBoost in both Spark and Flink, and possibly more frameworks in Future.
We have made the API in a portable way so it **can be easily ported to other Dataflow frameworks provided by the Cloud**.
XGBoost4J shares its core with other XGBoost libraries, which means data scientists can use R/python
read and visualize the model trained distributedly.
It also means that user can start with single machine version for exploration,
which already can handle hundreds of million examples.

xgboost/rabit/include/rabit/internal/timer.h  view on Meta::CPAN 

 */
inline double GetTime(void) {
  #ifdef __MACH__
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
  utils::Check(clock_get_time(cclock, &mts) == 0, "failed to get time");
  mach_port_deallocate(mach_task_self(), cclock);
  return static_cast<double>(mts.tv_sec) + static_cast<double>(mts.tv_nsec) * 1e-9;
  #else
  #if defined(__unix__) || defined(__linux__)
  timespec ts;
  utils::Check(clock_gettime(CLOCK_REALTIME, &ts) == 0, "failed to get time");
  return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) * 1e-9;
  #else
  return static_cast<double>(time(NULL));
  #endif
  #endif
}
}  // namespace utils
}  // namespace rabit



( run in 1.216 second using v1.01-cache-2.11-cpan-39bf76dae61 )