void arow::update(
const common::sfv_t& sfv,
float alpha,
float beta,
const std::string& pos_label,
const std::string& neg_label) {
storage::storage_base* sto = get_storage();
for (common::sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it) {
const string& feature = it->first;
float val = it->second;
storage::feature_val2_t ret;
sto->get2(feature, ret);
storage::val2_t pos_val(0.f, 1.f);
storage::val2_t neg_val(0.f, 1.f);
ClassifierUtil::get_two(ret, pos_label, neg_label, pos_val, neg_val);
sto->set2(
feature,
pos_label,
storage::val2_t(
pos_val.v1 + alpha * pos_val.v2 * val,
pos_val.v2 - beta * pos_val.v2 * pos_val.v2 * val * val));
if (neg_label != "") {
sto->set2(
feature,
neg_label,
storage::val2_t(
neg_val.v1 - alpha * neg_val.v2 * val,
neg_val.v2 - beta * neg_val.v2 * neg_val.v2 * val * val));
}
}
}
void confidence_weighted::update(
const common::sfv_t& sfv,
float step_width,
const string& pos_label,
const string& neg_label) {
util::concurrent::scoped_wlock lk(storage_->get_lock());
for (common::sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it) {
const string& feature = it->first;
float val = it->second;
storage::feature_val2_t val2;
storage_->get2_nolock(feature, val2);
storage::val2_t pos_val(0.f, 1.f);
storage::val2_t neg_val(0.f, 1.f);
ClassifierUtil::get_two(val2, pos_label, neg_label, pos_val, neg_val);
const float C = config_.regularization_weight;
float covar_pos_step = 2.f * step_width * val * val * C;
float covar_neg_step = 2.f * step_width * val * val * C;
storage_->set2_nolock(
feature,
pos_label,
storage::val2_t(pos_val.v1 + step_width * pos_val.v2 * val,
1.f / (1.f / pos_val.v2 + covar_pos_step)));
if (neg_label != "") {
storage_->set2_nolock(
feature,
neg_label,
storage::val2_t(neg_val.v1 - step_width * neg_val.v2 * val,
1.f / (1.f / neg_val.v2 + covar_neg_step)));
}
}
touch(pos_label);
}
void normal_herd::update(
const common::sfv_t& sfv,
float margin,
float variance,
const string& pos_label,
const string& neg_label) {
storage::storage_base* sto = get_storage();
for (common::sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it) {
const string& feature = it->first;
float val = it->second;
storage::feature_val2_t ret;
sto->get2(feature, ret);
storage::val2_t pos_val(0.f, 1.f);
storage::val2_t neg_val(0.f, 1.f);
ClassifierUtil::get_two(ret, pos_label, neg_label, pos_val, neg_val);
float val_covariance_pos = val * pos_val.v2;
float val_covariance_neg = val * neg_val.v2;
const float C = config_.C;
sto->set2(
feature,
pos_label,
storage::val2_t(
pos_val.v1
+ (1.f - margin) * val_covariance_pos
/ (val_covariance_pos * val + 1.f / C),
1.f
/ ((1.f / pos_val.v2) + (2 * C + C * C * variance)
* val * val)));
if (neg_label != "") {
sto->set2(
feature,
neg_label,
storage::val2_t(
neg_val.v1
- (1.f - margin) * val_covariance_neg
/ (val_covariance_neg * val + 1.f / C),
1.f
/ ((1.f / neg_val.v2) + (2 * C + C * C * variance)
* val * val)));
}
}
}
void CW::update(const sfv_t& sfv, float step_width, const string& pos_label, const string& neg_label){
for (sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it){
const string& feature = it->first;
float val = it->second;
storage::feature_val2_t val2;
storage_->get2(feature, val2);
storage::val2_t pos_val(0.f, 1.f);
storage::val2_t neg_val(0.f, 1.f);
ClassifierUtil::get_two(val2, pos_label, neg_label, pos_val, neg_val);
const float C = config.C;
float covar_pos_step = 2.f * step_width * pos_val.v2 * val * val * C;
float covar_neg_step = 2.f * step_width * neg_val.v2 * val * val * C;
storage_->set2(feature, pos_label,
storage::val2_t(pos_val.v1 + step_width * pos_val.v2 * val,
1.f / (1.f / pos_val.v2 + covar_pos_step)));
if (neg_label != "")
storage_->set2(feature, neg_label,
storage::val2_t(neg_val.v1 - step_width * neg_val.v2 * val,
1.f / (1.f / neg_val.v2 + covar_neg_step)));
}
}
void NHERD::update(const sfv_t& sfv, float margin, float variance,
const string& pos_label, const string& neg_label){
for (sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it){
const string& feature = it->first;
float val = it->second;
storage::feature_val2_t ret;
storage_->get2(feature, ret);
storage::val2_t pos_val(0.f, 1.f);
storage::val2_t neg_val(0.f, 1.f);
ClassifierUtil::get_two(ret, pos_label, neg_label, pos_val, neg_val);
float val_covariance_pos = val * pos_val.v2;
float val_covariance_neg = val * neg_val.v2;
storage_->set2(feature, pos_label,
storage::val2_t(pos_val.v1 + (1.f - margin) * val_covariance_pos / (val_covariance_pos * val + 1.f / C_),
1.f / ((1.f / pos_val.v2) + (2 * C_ + C_ * C_ * variance) * val * val)));
if (neg_label != "")
storage_->set2(feature, neg_label,
storage::val2_t(neg_val.v1 - (1.f - margin) * val_covariance_neg / (val_covariance_neg * val + 1.f / C_),
1.f / ((1.f / neg_val.v2) + (2 * C_ + C_ * C_ * variance) * val * val)));
}
}
int solve(int **puz, int *x, int *y, int display){
/*solves the given sudoku stored in puz, returns 1 if solve successful, returns WRONG_IP if i/p was invalid*/
int *p, s = 0, count = 0, r, q;
srand(time(NULL));
int i, j, val;
istack w;
char c, chk;
pstack POS;
init(&POS);
chk = check_ip(puz);
if(chk == WRONG_IP){
return WRONG_IP;
}
if(x == NULL){
i = j = 0;
}
else{
i = *x;
j = *y;
}
while(i != ROW){
empty_cell(puz, &i, &j);
if(!f.found){
if(display){
display_puz(puz);
refresh();
}
return 1;
}
p = scan(puz, i, j);
if(p == NULL){
return WRONG_IP;
}
w = pos_val(p);
check:
if(i_empty(&w)){
/*no possible values*/
if(!empty(&POS)){
w = pop(&POS);
puz[i][j] = EMPTY;
if(display){
display_puz(puz);
refresh();
}
count--;
i = cell[count].x;
j = cell[count].y;
goto check;
}
}
else if(!i_empty(&w)){
val = i_pop(&w);
push(&POS, w);
cell[count].x = i;
cell[count].y = j;
count++;
}
puz[i][j] = val;
if(display){
display_puz(puz);
refresh();
}
traverse_line(&i, &j);
}
f.flag = 0;
return 1;
}