double utils_eval_gmm(double* I, double* mu, double* cov, double* pi, int dim, int K) {
double p = 0;
for (int k = 0; k < K; ++k) {
double np = normpdf(I, mu + dim*k, cov + dim*k, dim);
p += pi[k]*np;
}
return p;
}
VectorXd CGppe::deriv_log_likelihood_CGppe_fast(double sigma, const TypePair& all_pairs, VectorXd idx_global_1, VectorXd idx_global_2, int M, int N)
{
VectorXd deriv_loglike, z, cdf_val, pdf_val, val;
// test if idx vectors are empty ?
M = all_pairs.rows();
int n = M * N;
z = (GetVec(f, idx_global_1) - GetVec(f, idx_global_2)) / sigma;
cdf_val = normcdf(z);
pdf_val = normpdf(z);
val = pow(sigma,-1) * (pdf_val.cwiseQuotient(cdf_val));
return Get_Cumulative_Val(idx_global_1, val, n) - Get_Cumulative_Val(idx_global_2, val, n);
}
bool my_RobustNormalFit(vector<double> &x,double *mu,double *sigma,double *PW)
{
size_t n=x.size();
*mu=my_mean(x);
*sigma=my_STD(x,*mu);
double a=my_min(x);
double b=my_max(x);
double alim=*mu-2*(*sigma);
double blim=*mu+2*(*sigma);
double L=alim-a+b-blim;
double K=b-a;
if(L<=0) return false;
size_t deltn=n-my_count(x,alim,blim);
double PW2=K*deltn/(L*n);
double PW1=1-PW2;
double muold=*mu;
double sigmaold=*sigma;
double e=1;
int iter=0;
double *PWP1,*PWAll;
PWP1=new double[n];
PWAll=new double[n];
size_t i;
while(e>0.0001)
{
for(i=0;i<n;i++)
{
PWP1[i]=PW1*normpdf(x[i],muold,sigmaold);
PWAll[i]=PWP1[i]+PW2/K;
PWP1[i]=PWP1[i]/PWAll[i];
}
PW1=my_sum(PWP1,n);
*mu=0;
for(i=0;i<n;i++)*mu+=PWP1[i]*x[i];
*mu/=PW1;
*sigma=0;
for(i=0;i<n;i++)*sigma+=PWP1[i]*(x[i]-muold)*(x[i]-muold);
*sigma=sqrt(*sigma/PW1);
PW1=PW1/n;
PW2=1-PW1;
e=fabs(*sigma-sigmaold)+fabs(*mu-muold);
muold=*mu;
sigmaold=*sigma;
iter=iter+1;
if(iter>100) break;
}
delete []PWP1;
delete []PWAll;
return true;
}
/*
* Generates a random directed binary graph with a Toeplitz organization.
*/
MATRIX_T* BCT_NAMESPACE::maketoeplitzCIJ(int N, int K, FP_T s) {
// profile = normpdf([1:N-1],0.5,s);
VECTOR_T* indices = sequence(1, N - 1);
VECTOR_T* profile = normpdf(indices, 0.5, s);
VECTOR_ID(free)(indices);
// template = toeplitz([0 profile],[0 profile]);
VECTOR_T* temp = concatenate(0.0, profile);
VECTOR_ID(free)(profile);
profile = temp;
MATRIX_T* _template = toeplitz(profile, profile);
VECTOR_ID(free)(profile);
// template = template.*(K./sum(sum(template)))
VECTOR_T* sum__template = sum(_template);
FP_T sum_sum__template = sum(sum__template);
VECTOR_ID(free)(sum__template);
MATRIX_ID(scale)(_template, (FP_T)K / sum_sum__template);
// CIJ = zeros(N);
MATRIX_T* CIJ = zeros(N);
// while ((sum(sum(CIJ)) ~= K))
VECTOR_T* sum_CIJ = sum(CIJ);
FP_T sum_sum_CIJ = sum(sum_CIJ);
VECTOR_ID(free)(sum_CIJ);
while ((int)sum_sum_CIJ != K) {
// CIJ = (rand(N)<template);
MATRIX_T* rand_N = rand(N);
MATRIX_ID(free)(CIJ);
CIJ = compare_elements(rand_N, fp_less, _template);
MATRIX_ID(free)(rand_N);
sum_CIJ = sum(CIJ);
sum_sum_CIJ = sum(sum_CIJ);
VECTOR_ID(free)(sum_CIJ);
}
MATRIX_ID(free)(_template);
return CIJ;
}
MatrixXd CGppe::deriv2_log_likelihood_CGppe_fast(double sigma, TypePair all_pairs, VectorXd idx_global_1, VectorXd idx_global_2, int M, int N)
{
VectorXd deriv_loglike, z, cdf_val, pdf_val, val, ratio, all_diag_idx, ind, ind_trans;
M = all_pairs.rows();
int n = M * N;
VectorXd consec(n);
MatrixXd Deriv2 = MatrixXd::Zero(n, n);
for (int i = 0;i < n;i++)
{
consec(i) = i;
}
all_diag_idx = sub2ind(n, n, consec, consec);
z = (GetVec(f, idx_global_1) - GetVec(f, idx_global_2)) / sigma;
cdf_val = normcdf(z);
pdf_val = normpdf(z);
ratio = pdf_val.array() / cdf_val.array();
val = -(1. / pow(sigma, 2)) * (ratio.array() * (z + ratio).array());
ind = sub2ind(n, n, idx_global_1, idx_global_2);
Deriv2 = SetMatGenIdx(Deriv2, ind, -val);
ind_trans = sub2ind(n, n, idx_global_2, idx_global_1);
Deriv2 = SetMatGenIdx(Deriv2, ind_trans, -val);
Deriv2 = SetMatGenIdx(Deriv2, all_diag_idx, GetMatGenIdx(Deriv2, all_diag_idx) + Get_Cumulative_Val(idx_global_1, val, n));
Deriv2 = SetMatGenIdx(Deriv2, all_diag_idx, GetMatGenIdx(Deriv2, all_diag_idx) + Get_Cumulative_Val(idx_global_2, val, n));
return Deriv2;
}
int main (int argc, char *argv[])
{ /* --- main function */
double mean = 0; /* mean value */
double var = 1; /* variance */
double x; /* argument value */
if ((argc < 2) || (argc > 4)){/* if wrong number of arguments */
printf("usage: %s arg [mean variance]\n", argv[0]);
printf("compute probability density function "
"of the normal distribution\n");
return 0; /* print a usage message */
} /* and abort the program */
x = atof(argv[1]); /* get the argument value */
if (argc > 2) mean = atof(argv[2]);
if (argc > 3) var = atof(argv[3]);
if (var < 0) { /* get the parameters */
printf("%s: invalid variance\n", argv[0]); return -1; }
printf("normal: f(%.16g; %.16g, %.16g) = %.16g\n",
x, mean, var, normpdf(x, mean, var));
return 0; /* compute and print density */
} /* main() */
double CGppe::maximum_expected_improvement(const VectorXd & theta_t, const VectorXd& theta_x, const double& sigma,
const MatrixXd& t, const MatrixXd & x, const VectorXd& idx_global, const VectorXd& ind_t, const VectorXd& ind_x, MatrixXd tstar, int N, double fbest)
{
VectorXd idx_xstar=Nfirst(N);
int Kt_ss = 1;
double mei;
MatrixXd Kx_star, Kx_star_star, kstar, Kss, Css;
MatrixXd Kt_star = covfunc_t->Compute(t, tstar);
//dsp(GetKinv(),"Kinv");
Kx_star = GetMatRow(Kx, idx_xstar.transpose()); //maybe need some transpose?
Kx_star_star = GetMat(Kx, idx_xstar.transpose(), idx_xstar.transpose()); // test to test
kstar = Kron(Kt_star, Kx_star);
kstar = GetMatRow(kstar, idx_global);
Kss = Kt_ss * Kx_star_star;
mustar = kstar.transpose() * Kinv * GetVec(f, idx_global);
Css = Kss - kstar.transpose() * W * llt.solve(Kinv * kstar);
varstar = Css.diagonal();
VectorXd sigmastar = sqrt(varstar.array());
VectorXd z = (fbest - mustar.array()) / sigmastar.array();
VectorXd pdfval = normpdf(z);
VectorXd cdfval = normcdf(z);
VectorXd inter = z.array() * (1 - cdfval.array());
VectorXd el = sigmastar.cwiseProduct(inter - pdfval);
el=-1*el;
mei = el.maxCoeff();
//dsp(mei,"mei");
return mei;
}
static PyObject *UtilsC_expectation_Z(PyObject *self, PyObject *args){
PyObject *q_Z,*Z_tilde,*graph,*Sigma_A,*m_A,*sigma_M,*Beta,*mu_M;
PyArrayObject *q_Zarray,*Z_tildearray,*grapharray,*Sigma_Aarray,*m_Aarray,*sigma_Marray,*Betaarray,*mu_Marray;
int j,J,K,k,m,maxNeighbours,nn,M;
PyArg_ParseTuple(args, "OOOOOOOOiiii",&Sigma_A,&m_A,&sigma_M, &Beta,&Z_tilde,&mu_M,&q_Z,&graph,&M,&J,&K,&maxNeighbours);
q_Zarray = (PyArrayObject *) PyArray_ContiguousFromObject(q_Z,PyArray_FLOAT64,3,3);
Z_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(Z_tilde,PyArray_FLOAT64,3,3);
grapharray = (PyArrayObject *) PyArray_ContiguousFromObject(graph,PyArray_INT,2,2);
Sigma_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_A,PyArray_FLOAT64,3,3);
sigma_Marray = (PyArrayObject *) PyArray_ContiguousFromObject(sigma_M,PyArray_FLOAT64,2,2);
m_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(m_A,PyArray_FLOAT64,2,2);
mu_Marray = (PyArrayObject *) PyArray_ContiguousFromObject(mu_M,PyArray_FLOAT64,2,2);
Betaarray = (PyArrayObject *) PyArray_ContiguousFromObject(Beta,PyArray_FLOAT64,1,1);
npy_float64 tmp[K],Emax,Sum,alpha[K],Malpha,extern_field,Gauss[K],local_energy,energy[K],Probas[K];
for (j=0;j<J;j++){
for (m=0;m<M;m++){
Malpha = 0;
for (k=0;k<K;k++){
alpha[k] = -0.5*GetValue3D(Sigma_Aarray,m,m,j) / (eps + GetValue(sigma_Marray,m,k) );
Malpha += alpha[k]/K;
}
for (k=0;k<K;k++){
alpha[k] /= Malpha;
tmp[k] = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours){
tmp[k] += GetValue3D(Z_tildearray,m,k,GetValueInt(grapharray,j,nn));
nn++;
}
}
Emax = 0;
for (k=0;k<K;k++){
energy[k] = 0;
extern_field = log( normpdf(GetValue(m_Aarray,j,m),GetValue(mu_Marray,m,k), sqrt(GetValue(sigma_Marray,m,k)) ) +eps);
if (extern_field < -100) extern_field = -100;
extern_field += alpha[k];
local_energy = GetValue(Betaarray,m,0) * tmp[k];
energy[k] += local_energy + extern_field;
if (energy[k] > Emax) Emax = energy[k];
}
Sum = 0;
for (k=0;k<K;k++){
Probas[k] = exp( energy[k] - Emax );
Sum += Probas[k];
}
for (k=0;k<K;k++){
GetValue3D(Z_tildearray,m,k,j) = Probas[k] / (Sum + eps);
}
}
}
/*--------------------------------------------------------------*/
for (j=0;j<J;j++){
for (m=0;m<M;m++){
Malpha = 0;
for (k=0;k<K;k++){
alpha[k] = -0.5*GetValue3D(Sigma_Aarray,m,m,j) / (eps + GetValue(sigma_Marray,m,k) );
Malpha += alpha[k]/K;
}
for (k=0;k<K;k++){
tmp[k] = 0;
nn = 0;
alpha[k] /= Malpha;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours){
tmp[k] += GetValue3D(Z_tildearray,m,k,GetValueInt(grapharray,j,nn));
nn++;
}
}
Emax = 0;
for (k=0;k<K;k++){
energy[k] = 0;
extern_field = alpha[k];
local_energy = GetValue(Betaarray,m,0) * tmp[k];
energy[k] += local_energy + extern_field;
if (energy[k] > Emax) Emax = energy[k];
Gauss[k] = normpdf(GetValue(m_Aarray,j,m),GetValue(mu_Marray,m,k), sqrt(GetValue(sigma_Marray,m,k)) );
}
Sum = 0;
for (k=0;k<K;k++){
Probas[k] = exp( energy[k] - Emax );
Sum += Probas[k];
}
for (k=0;k<K;k++){
GetValue3D(q_Zarray,m,k,j) = Gauss[k]*Probas[k] / (Sum + eps);
}
Sum = 0;
for (k=0;k<K;k++){
Sum += GetValue3D(q_Zarray,m,k,j);
}
for (k=0;k<K;k++){
GetValue3D(q_Zarray,m,k,j) /= Sum;
}
}
}
Py_DECREF(grapharray);
Py_DECREF(q_Zarray);
Py_DECREF(Z_tildearray);
Py_DECREF(m_Aarray);
Py_DECREF(mu_Marray);
Py_DECREF(Sigma_Aarray);
Py_DECREF(Betaarray);
Py_DECREF(sigma_Marray);
Py_INCREF(Py_None);
return Py_None;
}
