void Stabilisator::update_pi(CplexSolver & solver, DoubleVector const & pi) {
DoubleVector rc;
solver.rc(rc);
_pi_bar = pi;
int n_rows((int) _pi_bar.size());
// std::cout << "avg = " << avg / _pi_bar.size() << std::endl;
_dual_cost.assign(4 * _pi_bar.size(), 0);
_cost.assign(4 * _pi_bar.size(), 0);
_indexes.assign(4 * _pi_bar.size(), 0);
int index(-1);
for (int row(0); row < n_rows; ++row) {
_cost[++index] = gamma1(row);
_dual_cost[index] = dseta_m();
_indexes[index] = index;
_cost[++index] = delta1(row);
_dual_cost[index] = epsilon_m();
_indexes[index] = index;
_cost[++index] = -delta2(row);
_dual_cost[index] = epsilon_p();
_indexes[index] = index;
_cost[++index] = -gamma2(row);
_dual_cost[index] = dseta_p();
_indexes[index] = index;
}
solver.chgObj(_indexes, _cost);
}
float tgamma(float x)
{
// Check for pure zero argument.
if(xcmath::near_integer(x, std::uint_least8_t(0U)))
{
return std::numeric_limits<float>::quiet_NaN();
}
// Check for overflow and underflow.
if( (x > 35)
|| ((x > -1.0E-4F) && (x < 1.0E-4F))
)
{
return std::numeric_limits<float>::infinity();
}
// Is the argument 1 or 2?
if( xcmath::near_integer(x, std::uint_least8_t(1U))
|| xcmath::near_integer(x, std::uint_least8_t(2U))
)
{
return 1.0F;
}
// Use a positive argument for the Gamma calculation.
const bool b_neg = (x < 0);
x = (b_neg ? -x : x);
// Get any integer recursion and scale the argument.
const std::uint16_t nx = std::uint16_t(::floor(x));
x -= float(nx);
float g = gamma1(x);
// Do the recursion if necessary.
for(std::uint16_t recur = 0U; recur < nx; ++recur)
{
g *= x;
++x;
}
// Return (and possibly reflect) the result.
if(false == b_neg)
{
return g;
}
else
{
const float sin_pi_x = sin(const_pi<float>() * x);
return -const_pi<float>() / ((x * g) * sin_pi_x);
}
}
std::string ThreeSstarCoeffs::str() const
{
std::stringstream ss;
for (int i=0; i<nb_stages(); ++i)
{
ss << std::setw(2) << i << ": "
<< std::setw(9) << delta(i)
<< std::setw(9) << beta(i)
<< std::setw(9) << gamma1(i)
<< std::setw(9) << gamma2(i)
<< std::setw(9) << gamma3(i);
ss << std::endl;
}
return ss.str();
}
void UntiedGaussMixtureDensityEBTrainer::retrain(const DataSet& traindata) {
vector<uint> maxApproxIdx(N_);
for(uint it=0;it<maxIterations_;++it) {
UntiedGaussMixtureDensityClassifier oldClassifier(classifier_);
DBG(10) << "Iteration " << it+1 << "/" << maxIterations_ <<"." << endl;
for(uint c=0;c<C_;++c) {
DBG(10) << "Iteration " << it+1 << "/" << maxIterations_ <<" class " << c << "/" << C_ << "." << std::endl;
uint I=classifier_.mixtures_[c].numberOfClusters();
GaussMixtureDensity& gmdi=classifier_.mixtures_[c];
vector<double> gamma1(I*D_,0.0);
vector<double> gammaX(I*D_,0.0);
vector<double> gammaX2(I*D_,0.0);
DBG(15) << "Getting gammas" << endl;
for(uint n=0;n<N_;++n) {
double maxLogPx=-numeric_limits<double>::max();
for(uint i=0;i<I;++i) {
double logpx=gmdi.logp_x(traindata[n]);
if(logpx>maxLogPx) {
maxLogPx=logpx;
maxApproxIdx[n]=i;
}
vector<double> p_cn_xn; classifier.p_c_x(traindata[n],p_cn_xn);
double gamma=1.0/double(N_)*criterion_->fprime(traindata[n],c,classifier_)*(delta(c,traindata[n].cls())-p_cn_xn[c]);
uint in=maxApproxIdx[n];
for(uint d=0;d<D_;++d) {
uint idx=d*I+in;
double xd=traindata[n][d];
gamma1[idx]+=gamma;
gammaX[idx]+=gamma*xd;
gammaX2[idx]+=gamma*xd*xd;
}
}
}
} // for c
} // for it
}
//----------------------
float tmVisThreshC1_MixtureModeling2::differenceGamma (int i) {
return gamma1(i)-gamma2(i);
}
//----------------------
float tmVisThreshC1_MixtureModeling2::gamma (int i) {
return gamma1(i)+gamma2(i);
}
