virtual void copy_from(const AzpActivDflt *i) { p = i->p; m_drv.set(&i->m_drv); v_border.set(&i->v_border); v_pop.set(&i->v_pop); v_pop_last.set(&i->v_pop_last); }
/*-------------------------------------------------------------*/ void AzDmat::prod(const AzDmat *m0, const AzDmat *m1, bool is_m0_tran, bool is_m1_tran) { const char *eyec = "AzDmat::prod"; if (is_m1_tran) { throw new AzException(eyec, "No support for the transpose of the second matrix"); } if (is_m0_tran) { reform(m0->colNum(), m1->colNum()); for (int col = 0; col < m1->colNum(); ++col) { AzDvect *myv = col_u(col); const AzDvect *v1 = m1->col(col); for (int row = 0; row < rowNum(); ++row) { double val = m0->col(col)->innerProduct(v1); myv->set(row, val); } } } else { reform(m0->rowNum(), m1->colNum()); for (int col = 0; col < m1->colNum(); ++col) { AzDvect *myv = col_u(col); const AzDvect *v1 = m1->col(col); for (int row1 = 0; row1 < v1->rowNum(); ++row1) { myv->add(m0->col(row1), v1->get(row1)); } } } }
void _reset() { v_w.reset(); v_p.reset(); v_y.reset(); v_fixed_dw.reset(); var_const = fixed_const = 0; }
void reset(const AzTrTtarget *inp) { if (inp != NULL) { v_tar_dw.set(&inp->v_tar_dw); v_dw.set(&inp->v_dw); v_y.set(&inp->v_y); v_fixed_dw.set(&inp->v_fixed_dw); fixed_dw_sum = inp->fixed_dw_sum; } }
/*--- to keep count ---*/ void init_count() { // const double border[] = {0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 2, 3, 9999999999, -1}; #define AzpActivDfltCountStop 7777 const double border[] = {-1e+10, -10, -5, -1, -0.5, -0.2, -0.1, 0, 0.1, 0.2, 0.5, 1, 5, 10, 1e+10, AzpActivDfltCountStop}; int num = 0; int ix; for (ix = 0; ; ++ix, ++num) if (border[ix] == AzpActivDfltCountStop) break; v_border.set(border, num); v_pop.reform(num); }
/*---*/ void resetDw(const AzDvect *inp_v_dw) { if (!AzDvect::isNull(inp_v_dw)) { if (inp_v_dw->rowNum() != v_y.rowNum()) { throw new AzException("AzOptOnTree::resetDw", "dimensionality conflict"); } v_fixed_dw.set(inp_v_dw); } else { v_fixed_dw.destroy(); } }
/*----------------------------------------------------------------------*/ void AzSvDataS::mergeData(const AzSmat *m_x, const AzSvFeatInfo *feat, const char *fn_template, const char *str, bool doSparse, int digits, const char *out_x_fn, const char *out_n_fn, int num, const char *names[]) { const char *eyec = "AzSvDataS::mergeData"; int data_num = m_x->colNum(); int f_num = m_x->rowNum(); if (feat->featNum() != f_num) { throw new AzException(eyec, "Conflict btw m_x and featInfo"); } AzFile n_file(out_n_fn); n_file.open("wb"); int fx; for (fx = 0; fx < feat->featNum(); ++fx) { AzBytArr s; feat->desc(fx, &s); s.nl(); s.writeText(&n_file); } AzSmat m; m_x->transpose(&m); m.resize(data_num, f_num+num); AzStrPool sp_names; for (fx = 0; fx < num; ++fx) { AzBytArr s_fn(fn_template); s_fn.replace("*", names[fx]); AzDvect v; AzSvDataS::readVector(s_fn.c_str(), &v); if (v.rowNum() != m.rowNum()) { throw new AzException(AzInputError, eyec, "conflict in #data:", s_fn.c_str()); } m.col_u(f_num+fx)->set(&v); AzBytArr s_nm; if (AzTools::isSpecified(str)) s_nm.c(str); s_nm.c(names[fx]); s_nm.nl(); s_nm.writeText(&n_file); } n_file.close(true); AzSmat m1; m.transpose(&m1); m1.writeText(out_x_fn, digits, doSparse); }
void count(const AzPmat *m) { if (v_border.rowNum() == 0) init_count(); AzDmat md; m->get(&md); const double *border = v_border.point(); int row, col; for (col = 0; col < md.colNum(); ++col) { for (row = 0; row < md.rowNum(); ++row) { double val = md.get(row, col); int bx; for (bx = 0; bx < v_border.rowNum(); ++bx) { if (val <= border[bx]) { v_pop.add(bx, 1); break; } } } } }
AzSortedFeat_Sparse & operator =(const AzSortedFeat_Sparse &inp) { /* never tested */ if (this == &inp) return *this; ia_zero.reset(&inp.ia_zero); ia_index.reset(&inp.ia_index); v_value.set(&inp.v_value); _shouldDoBackward = inp._shouldDoBackward; data_num = inp.data_num; return *this; }
/*--- this never returns NULL ---*/ inline const AzDvect *col(int col) const { if (col < 0 || col >= col_num) { throw new AzException("AzDmat::col", "col# is out of range"); } if (column[col] == NULL) { if (dummy_zero.rowNum() != row_num) { throw new AzException("AzDmat::col", "wrong dummy_zero"); } return &dummy_zero; } return column[col]; }
void reset(const AzDvect *inp_v_y, const AzDvect *inp_v_fixed_dw=NULL) { v_dw.reform(inp_v_y->rowNum()); v_dw.set(1); v_tar_dw.set(inp_v_y); v_y.set(inp_v_y); fixed_dw_sum = -1; v_fixed_dw.reset(); if (!AzDvect::isNull(inp_v_fixed_dw)) { v_fixed_dw.set(inp_v_fixed_dw); if (v_fixed_dw.rowNum() != v_y.rowNum()) { throw new AzException(AzInputError, "AzTrTtarget::reset", "conlict in dimensionality: y and data point weights"); } fixed_dw_sum = v_fixed_dw.sum(); } }
virtual void show_stat(AzBytArr &s) const { if (p.typ == AzpActivDflt_None) return; if (!p.do_stat) return; AzDvect my_v_pop(&v_pop_last); my_v_pop.normalize1(); s.nl(); double accum = 0; int ix; for (ix = 0; ix < my_v_pop.rowNum(); ++ix) { accum += my_v_pop.get(ix); s.c("b"); s.cn(v_border.get(ix)); s.c("="); s.cn(my_v_pop.get(ix),3); s.c("("); s.cn(accum,3); s.c("),"); } }
inline void weight_tarDw() { v_tar_dw.scale(&v_fixed_dw); }
inline void copyPred_to(AzDvect *out_v_p) const { out_v_p->reform(v_p.rowNum()); out_v_p->set(&v_p); }
void end_of_epoch() { if (p.typ == AzpActivDflt_None) return; v_pop_last.set(&v_pop); v_pop.zeroOut(); }
void _release() { checkLock("_release"); a.free(&column); col_num = 0; row_num = 0; dummy_zero.reform(0); }
inline const double *tarDw_arr() const { return v_tar_dw.point(); }
inline const double *dw_arr() const { return v_dw.point(); }
void resetTarDw_residual(const AzDvect *v_p) { /* only for LS */ v_tar_dw.set(&v_y); v_tar_dw.add(v_p, -1); }
void resetTargetDw(const AzDvect *v_tar, const AzDvect *inp_v_dw) { v_tar_dw.set(v_tar); v_dw.set(inp_v_dw); v_tar_dw.scale(&v_dw); /* component-wise multiplication */ }
inline int dataNum() const { return v_tar_dw.rowNum(); }
inline void weight_dw() { v_dw.scale(&v_fixed_dw); }
inline double getDwSum(const int *dxs, int dxs_num) const { return v_dw.sum(dxs, dxs_num); }
int dim() const { return v_tar_dw.rowNum(); }
inline double getDwSum(const AzIntArr *ia_dx=NULL) const { return v_dw.sum(ia_dx); }