10 #include <boost/accumulators/accumulators.hpp> 
   11 #include <boost/accumulators/statistics/stats.hpp> 
   12 #include <boost/accumulators/statistics/mean.hpp> 
   13 #include <boost/accumulators/statistics/min.hpp> 
   14 #include <boost/accumulators/statistics/max.hpp> 
   15 #include <boost/foreach.hpp> 
   16 #include <boost/format.hpp> 
   17 #include <boost/thread/mutex.hpp> 
   36   features.push_back(f);
 
   38     light_features.push_back(features.size()-1);
 
   44   offsets.resize(features.size()+1);
 
   46   for (
size_t i=0; i<features.size(); ++i)
 
   47     offsets[i+1] = offsets[i] + features[i].dimension();
 
   56   for (
size_t i=0; i<
features.size(); ++i) {
 
   65   return exp(matchNoExp(state, move, weights));
 
   72   assert(offsets.size() == features.size()+1);
 
   74   BOOST_FOREACH(
size_t i, light_features) {
 
   75     sum += features[i].match(state, info, offsets[i], weights);
 
   86   vector<std::pair<double, std::string> > 
out;
 
   87   for (
size_t i=0; i<features.size(); ++i) {
 
   88     double s = features[i].match(state, info, offsets[i], weights);
 
   90       out.push_back(make_pair(s, features[i].name()));
 
   92   std::sort(out.begin(), out.end());
 
   93   std::reverse(out.begin(), out.end());
 
   94   for (
size_t i=0; i<out.size(); ++i) {
 
   95     std::cerr << boost::format(
"%16s %6.2f ") % out[i].second % out[i].first;
 
   99   if (out.size() % 3 != 0)
 
  105                const double * weights)
 const 
  107   assert(! state.
dirty);
 
  111   FixedCapacityVector<Move,128> unpromote_moves;
 
  112   BOOST_FOREACH(
Move move, moves) {
 
  113     double score = matchExp(state, move, weights);
 
  122                 double sum, MoveLogProbVector& 
out)
 
  124   static const double scale = 100.0 / log(0.5);
 
  126     double p = move.first/sum;
 
  127     if (std::isnan(p) || p <= 1.0/(1<<12)) 
 
  129     const int logp = 
std::max(50, static_cast<int>(log(p)*scale));
 
  132   out.sortByProbability();
 
  137                 const double * weights)
 const 
  140   double sum = generateRating(state, moves, weights);
 
  141   ratingToLogProb(moves, sum, out);
 
  145 load(
const char *base_filename, 
double * weights)
 const 
  147   std::string filename = std::string(base_filename) + 
".txt";
 
  148   std::fill(weights, weights+dimension(), 0.0);
 
  149   std::ifstream is(filename.c_str());
 
  150   for (
int i=0; i<dimension(); ++i) {
 
  153       std::cerr << 
"load failed at " << i << 
" in " << dimension()
 
  154                 << 
" file " << filename << 
"\n";
 
  164   std::string filename = std::string(base_filename) + 
".bin";
 
  165   std::fill(weights, weights+dimension(), 0.0);
 
  166   std::ifstream is(filename.c_str(), std::ios_base::binary);
 
  168   for (
int i=0; i<dimension(); ++i) {
 
  169     if (! reader.hasNext()) {
 
  170       std::cerr << 
"load failed at " << i << 
" in " << dimension()
 
  171                 << 
" file " << filename << 
"\n";
 
  174     double value = reader.read();
 
  183   for (
size_t i=0; i<features.size(); ++i) {
 
  184     const Feature& f = features[i];
 
  185 #if (__GNUC_MINOR__ < 5) 
  186     using namespace boost::accumulators;
 
  187     accumulator_set<double, stats<tag::mean, tag::min, tag::max> > acc;
 
  190     for (
int j=offsets[i]; j<offsets[i+1]; ++j)
 
  192 #if (__GNUC_MINOR__ < 5) 
  198     std::cerr << std::setw(16) << f.
name() 
 
  199               << 
" dim " << std::setw(5) << f.
dimension() - zero
 
  201 #if (__GNUC_MINOR__ < 5) 
  202               << 
" min " << std::setw(6) << 
min(acc)
 
  203               << 
" max " << std::setw(6) << 
max(acc)
 
  204               << 
" mean " << std::setw(6) << mean(acc)
 
  282   the_instance.
setUp(verbose);
 
  289   return instance(
true).ok();
 
  294   namespace move_probability 
 
  303   static bool initialized = 
false;
 
  307   weights.reset(
new double[dimension()]);
 
  309   filename += 
"/data/move-order";
 
  311     std::cerr << 
"loading " << filename << 
".bin ";
 
  312   const bool success = load_binary(filename.c_str(), &weights[0]);
 
  314     std::cerr << (success ? 
"success" : 
"failed\a") << 
"\n";
 
  317   filename += 
"/data/move-tactical.txt";
 
  318   const int tactical_dimension = 8*4;
 
  319   tactical_weights.reset(
new double[tactical_dimension]);
 
  321     std::cerr << 
"loading " << filename << 
" ";
 
  322   std::ifstream is(filename.c_str());
 
  323   for (
int i=0; i<tactical_dimension; ++i)
 
  324     is >> tactical_weights[i];
 
  326     std::cerr << (is ? 
"success" : 
"failed\a") << 
"\n";
 
  327   this->initialized = success && is;
 
  328   return this->initialized;
 
  342   double elapsed = 0.0, welapsed = 0.0, last_p = 1.0;
 
  343   std::sort(moves.begin(), moves.end());
 
  344   for (
int i=moves.size()-1; i>=0; --i) {
 
  346     static const double scale = 100.0 / log(0.5);
 
  347     if (i+1<(
int)moves.size())
 
  349     double p = move.first/(sum-elapsed+welapsed);
 
  350     if (std::isnan(p) || p <= 1.0/(1<<12)) 
 
  354     int logp = 
std::max(50, static_cast<int>(log(p)*scale));
 
  355     if (moves.size() - i <= 8)
 
  357     else if (moves.size() - i <= 16)
 
  360     elapsed += move.first;
 
  361     welapsed = (welapsed+move.first)*(moves.size()-i)/moves.size();
 
  368   generateLogProb2(state, out);
 
  393   const double sum = matchLight(state, target);
 
  394   return tacticalLogProb(progress8*4 + 0, sum);
 
  401   const double sum = matchLight(state, target);
 
  402   return tacticalLogProb(progress8*4 + 2, sum);
 
  408   static const double scale = 100.0 / log(0.5);
 
  409   double x = tactical_weights[offset] * sum + tactical_weights[offset+1];
 
  410   double p = 1/(1.0+exp(-x));
 
  411   return std::max(50, static_cast<int>(log(p)*scale));