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);
}
