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