double EncoderLearnerTagger::gradient(double *expected) {
viterbi();
for (int pos = 0; pos <= static_cast<long>(len_); ++pos) {
for (LearnerNode *node = begin_node_list_[pos]; node; node = node->bnext) {
calc_alpha(node);
}
}
for (int pos = static_cast<long>(len_); pos >=0; --pos) {
for (LearnerNode *node = end_node_list_[pos]; node; node = node->enext) {
calc_beta(node);
}
}
double Z = begin_node_list_[len_]->alpha; // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len_); ++pos) {
for (LearnerNode *node = begin_node_list_[pos]; node; node = node->bnext) {
for (LearnerPath *path = node->lpath; path; path = path->lnext) {
calc_expectation(path, expected, Z);
}
}
}
for (size_t i = 0; i < ans_path_list_.size(); ++i) {
Z -= ans_path_list_[i]->cost;
}
return Z;
}
// static
bool Viterbi::forwardbackward(Lattice *lattice) {
if (!lattice->has_request_type(MECAB_MARGINAL_PROB)) {
return true;
}
Node **end_node_list = lattice->end_nodes();
Node **begin_node_list = lattice->begin_nodes();
const size_t len = lattice->size();
const double theta = lattice->theta();
end_node_list[0]->alpha = 0.0;
for (int pos = 0; pos <= static_cast<long>(len); ++pos) {
for (Node *node = begin_node_list[pos]; node; node = node->bnext) {
calc_alpha(node, theta);
}
}
begin_node_list[len]->beta = 0.0;
for (int pos = static_cast<long>(len); pos >= 0; --pos) {
for (Node *node = end_node_list[pos]; node; node = node->enext) {
calc_beta(node, theta);
}
}
const double Z = begin_node_list[len]->alpha;
lattice->set_Z(Z); // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len); ++pos) {
for (Node *node = begin_node_list[pos]; node; node = node->bnext) {
node->prob = std::exp(node->alpha + node->beta - Z);
for (Path *path = node->lpath; path; path = path->lnext) {
path->prob = std::exp(path->lnode->alpha
- theta * path->cost
+ path->rnode->beta - Z);
}
}
}
return true;
}
bool Viterbi::forwardbackward(const char *sentence, size_t len) {
if (!this->viterbi(sentence, len)) return false;
end_node_list_[0]->alpha = 0.0;
for (int pos = 0; pos <= static_cast<long>(len); ++pos)
for (Node *node = begin_node_list_[pos]; node; node = node->bnext)
calc_alpha(node, theta_);
begin_node_list_[len]->beta = 0.0;
for (int pos = static_cast<long>(len); pos >= 0; --pos)
for (Node *node = end_node_list_[pos]; node; node = node->enext)
calc_beta(node, theta_);
Z_ = begin_node_list_[len]->alpha; // alpha of EOS
for (int pos = 0; pos <= static_cast<long>(len); ++pos)
for (Node *node = begin_node_list_[pos]; node; node = node->bnext)
node->prob = std::exp(node->alpha + node->beta - Z_);
return true;
}
/**
*
* NUFFT operator initialization
*
* @param N - number of dimensions
* @param ksp_dims - kspace dimension
* @param cim_dims - coil images dimension
* @param traj - trajectory
* @param conf - configuration options
* @param use_gpu - use gpu boolean
*
*/
struct linop_s* nufft_create(unsigned int N, const long ksp_dims[N], const long cim_dims[N], const long traj_dims[N], const complex float* traj, const complex float* weights, struct nufft_conf_s conf, bool use_gpu)
{
struct nufft_data* data = (struct nufft_data*)xmalloc(sizeof(struct nufft_data));
data->N = N;
data->use_gpu = use_gpu;
data->traj = traj;
data->conf = conf;
data->width = 3.;
data->beta = calc_beta(2., data->width);
// get dims
assert(md_check_compat(N - 3, 0, ksp_dims + 3, cim_dims + 3));
unsigned int ND = N + 3;
data->ksp_dims = xmalloc(ND * sizeof(long));
data->cim_dims = xmalloc(ND * sizeof(long));
data->cml_dims = xmalloc(ND * sizeof(long));
data->img_dims = xmalloc(ND * sizeof(long));
data->trj_dims = xmalloc(ND * sizeof(long));
data->lph_dims = xmalloc(ND * sizeof(long));
data->psf_dims = xmalloc(ND * sizeof(long));
data->wgh_dims = xmalloc(ND * sizeof(long));
data->ksp_strs = xmalloc(ND * sizeof(long));
data->cim_strs = xmalloc(ND * sizeof(long));
data->cml_strs = xmalloc(ND * sizeof(long));
data->img_strs = xmalloc(ND * sizeof(long));
data->trj_strs = xmalloc(ND * sizeof(long));
data->lph_strs = xmalloc(ND * sizeof(long));
data->psf_strs = xmalloc(ND * sizeof(long));
data->wgh_strs = xmalloc(ND * sizeof(long));
md_singleton_dims(ND, data->cim_dims);
md_singleton_dims(ND, data->ksp_dims);
md_copy_dims(N, data->cim_dims, cim_dims);
md_copy_dims(N, data->ksp_dims, ksp_dims);
md_select_dims(ND, FFT_FLAGS, data->img_dims, data->cim_dims);
assert(3 == traj_dims[0]);
assert(traj_dims[1] == ksp_dims[1]);
assert(traj_dims[2] == ksp_dims[2]);
assert(md_check_compat(N - 3, ~0, traj_dims + 3, ksp_dims + 3));
assert(md_check_bounds(N - 3, ~0, traj_dims + 3, ksp_dims + 3));
md_singleton_dims(ND, data->trj_dims);
md_copy_dims(N, data->trj_dims, traj_dims);
// get strides
md_calc_strides(ND, data->cim_strs, data->cim_dims, CFL_SIZE);
md_calc_strides(ND, data->img_strs, data->img_dims, CFL_SIZE);
md_calc_strides(ND, data->trj_strs, data->trj_dims, CFL_SIZE);
md_calc_strides(ND, data->ksp_strs, data->ksp_dims, CFL_SIZE);
data->weights = NULL;
if (NULL != weights) {
md_singleton_dims(ND, data->wgh_dims);
md_select_dims(N, ~MD_BIT(0), data->wgh_dims, data->trj_dims);
md_calc_strides(ND, data->wgh_strs, data->wgh_dims, CFL_SIZE);
complex float* tmp = md_alloc(ND, data->wgh_dims, CFL_SIZE);
md_copy(ND, data->wgh_dims, tmp, weights, CFL_SIZE);
data->weights = tmp;
}
complex float* roll = md_alloc(ND, data->img_dims, CFL_SIZE);
rolloff_correction(2., data->width, data->beta, data->img_dims, roll);
data->roll = roll;
complex float* linphase = compute_linphases(N, data->lph_dims, data->img_dims);
md_calc_strides(ND, data->lph_strs, data->lph_dims, CFL_SIZE);
if (!conf.toeplitz)
md_zmul2(ND, data->lph_dims, data->lph_strs, linphase, data->lph_strs, linphase, data->img_strs, data->roll);
fftmod(ND, data->lph_dims, FFT_FLAGS, linphase, linphase);
fftscale(ND, data->lph_dims, FFT_FLAGS, linphase, linphase);
// md_zsmul(ND, data->lph_dims, linphase, linphase, 1. / (float)(data->trj_dims[1] * data->trj_dims[2]));
complex float* fftm = md_alloc(ND, data->img_dims, CFL_SIZE);
md_zfill(ND, data->img_dims, fftm, 1.);
fftmod(ND, data->img_dims, FFT_FLAGS, fftm, fftm);
data->fftmod = fftm;
data->linphase = linphase;
data->psf = NULL;
if (conf.toeplitz) {
#if 0
md_copy_dims(ND, data->psf_dims, data->lph_dims);
#else
md_copy_dims(3, data->psf_dims, data->lph_dims);
md_copy_dims(ND - 3, data->psf_dims + 3, data->trj_dims + 3);
data->psf_dims[N] = data->lph_dims[N];
#endif
md_calc_strides(ND, data->psf_strs, data->psf_dims, CFL_SIZE);
data->psf = compute_psf2(N, data->psf_dims, data->trj_dims, data->traj, data->weights);
}
md_copy_dims(ND, data->cml_dims, data->cim_dims);
data->cml_dims[N + 0] = data->lph_dims[N + 0];
md_calc_strides(ND, data->cml_strs, data->cml_dims, CFL_SIZE);
data->cm2_dims = xmalloc(ND * sizeof(long));
// !
md_copy_dims(ND, data->cm2_dims, data->cim_dims);
for (int i = 0; i < 3; i++)
data->cm2_dims[i] = (1 == cim_dims[i]) ? 1 : (2 * cim_dims[i]);
data->grid = md_alloc(ND, data->cml_dims, CFL_SIZE);
data->fft_op = linop_fft_create(ND, data->cml_dims, FFT_FLAGS, use_gpu);
return linop_create(N, ksp_dims, N, cim_dims,
data, nufft_apply, nufft_apply_adjoint, nufft_apply_normal, NULL, nufft_free_data);
}
void calculate_soil_water_fac(control *c, params *p, state *s) {
/* Estimate a relative water availability factor [0..1]
A drying soil results in physiological stress that can induce stomatal
closure and reduce transpiration. Further, N mineralisation depends on
top soil moisture.
s->qs = 0.2 in SDGVM
References:
-----------
* Landsberg and Waring (1997) Forest Ecology and Management, 95, 209-228.
See --> Figure 2.
* Egea et al. (2011) Agricultural Forest Meteorology, 151, 1370-1384.
But similarly see:
* van Genuchten (1981) Soil Sci. Soc. Am. J, 44, 892--898.
* Wang and Leuning (1998) Ag Forest Met, 91, 89-111.
* Pepper et al. (2008) Functional Change Biology, 35, 493-508
Returns:
--------
wtfac_topsoil : float
water availability factor for the top soil [0,1]
wtfac_root : float
water availability factor for the root zone [0,1]
*/
double moisture_ratio_topsoil, moisture_ratio_root, psi_swp_topsoil, theta;
if (c->sw_stress_model == 0) {
/* JULES type model, see Egea et al. (2011) */
s->wtfac_topsoil = calc_beta(s->pawater_topsoil, p->topsoil_depth,
p->theta_fc_topsoil, p->theta_wp_topsoil,
p->qs);
s->wtfac_root = calc_beta(s->pawater_root, p->rooting_depth,
p->theta_fc_root, p->theta_wp_root,
p->qs);
} else if (c->sw_stress_model == 1) {
/* Landsberg and Waring, (1997) */
moisture_ratio_topsoil = s->pawater_topsoil / p->wcapac_topsoil;
moisture_ratio_root = s->pawater_root / p->wcapac_root;
s->wtfac_topsoil = calc_sw_modifier(moisture_ratio_topsoil,
p->ctheta_topsoil,
p->ntheta_topsoil);
s->wtfac_root = calc_sw_modifier(moisture_ratio_root, p->ctheta_root,
p->ntheta_root);
} else if (c->sw_stress_model == 2) {
/*
Zhou et al.(2013) Agricultural & Forest Met. 182–183, 204–214
Assuming that overnight pre-dawn leaf water potential =
pre-dawn soil water potential.
*/
fprintf(stderr, "Zhou model not implemented\n");
exit(EXIT_FAILURE);
/*
s->wtfac_topsoil = exp(p->g1_b * s->psi_s_topsoil);
s->wtfac_root = exp(p->g1_b * s->psi_s_root);
! SW modifier for Vcmax (non-stomatal limitation)
s->wtfac_topsoil_ns = (1.0 + exp(p->vcmax_sf * p->vcmax_psi_f)) / \
(1.0 + exp(p->vcmax_sf * \
(p->vcmax_psi_f - s->psi_s_topsoil)));
s->wtfac_root_ns = (1.0 + exp(p->vcmax_sf * p->vcmax_psi_f)) / \
(1.0 + exp(p->vcmax_sf * \
(p->vcmax_psi_f - s->psi_s_root)));
*/
}
return;
}
DoubleVector StandardModel<Two_scale>::beta() const
{
return calc_beta().display();
}
