int recommender_serv::clear_row(std::string id) {
  check_set_config();

  ++clear_row_cnt_;
  rcmdr_.get_model()->clear_row(id);
  return 0;
}

similar_result recommender_serv::similar_row_from_id(
    std::string id,
    size_t ret_num) {
  check_set_config();

  return recommender_->similar_row_from_id(id, ret_num);
}

std::vector<std::vector<estimate_result> > classifier_serv::classify(std::vector<jubatus::datum> data) const {
  std::vector<std::vector<estimate_result> > ret;

  check_set_config();

  sfv_t v;
  fv_converter::datum d;
  for (size_t i = 0; i < data.size(); ++i) {

    convert<datum, fv_converter::datum>(data[i], d);
    converter_->convert(d, v);
    
    wm_.wm_->get_weight(v);

    classify_result scores;
    clsfer_.classifier_->classify_with_scores(v, scores);
    
    vector<estimate_result> r;
    for (vector<classify_result_elem>::const_iterator p = scores.begin();
         p != scores.end(); ++p){
      estimate_result e;
      e.label = p->label;
      e.prob = p->score;
      r.push_back(e);
      if( !isfinite(p->score) ){
        LOG(WARNING) << p->label << ":" << p->score;
      }
    }
    ret.push_back(r);
  }
  return ret; //std::vector<estimate_results> >::ok(ret);
}

float anomaly_serv::update(const string& id, const datum& data) {
  check_set_config();

  float score = anomaly_->update(id, data);
  DLOG(INFO) << "point updated: " << id;
  return score;
}

std::vector<std::string> recommender_serv::get_all_rows() {
  check_set_config();

  std::vector<std::string> ret;
  rcmdr_.get_model()->get_all_row_ids(ret);
  return ret;
}

bool recommender_serv::update_row(std::string id, datum dat) {
  check_set_config();

  ++update_row_cnt_;
  recommender_->update_row(id, dat);
  DLOG(INFO) << "row updated: " << id;

  return true;
}

int recommender_serv::clear()
{
  check_set_config();
  clear_row_cnt_ = 0;
  update_row_cnt_ = 0;
  build_cnt_ = 0;
  mix_cnt_ = 0;
  rcmdr_.get_model()->clear();
  return 0;
}

vector<float> regression_serv::estimate(
    const vector<datum>& data) const {
  check_set_config();

  vector<float> ret;

  for (size_t i = 0; i < data.size(); ++i) {
    ret.push_back(regression_->estimate(data[i]));
  }
  return ret;  // vector<estimate_results> >::ok(ret);
}

vector<float> regression_serv::estimate(const vector<jubatus::datum>& data) const {
  check_set_config();

  vector<float> ret;
  sfv_t v;
  fv_converter::datum d;
  for (size_t i = 0; i < data.size(); ++i) {
    convert<datum, fv_converter::datum>(data[i], d);
    converter_->convert(d, v);
    ret.push_back(regression_->estimate(v));
  }
  return ret; //vector<estimate_results> >::ok(ret);
}

int regression_serv::train(const vector<pair<float, jubatus::datum> >& data) {
  check_set_config();

  int count = 0;
  sfv_t v;
  fv_converter::datum d;
  
  for (size_t i = 0; i < data.size(); ++i) {
    convert<jubatus::datum, fv_converter::datum>(data[i].second, d);
    converter_->convert_and_update_weight(d, v);
    regression_->train(v, data[i].first);
    count++;
  }
  // FIXME: send count incrementation to mixer
  return count;
}