double CGppe::expected_voi(const VectorXd & theta_x, const VectorXd& theta_t, const double& sigma,
const MatrixXd& t, const MatrixXd & x, TypePair train_pairs, VectorXd& idx_global, VectorXd& ind_t, VectorXd& ind_x, MatrixXd test_pair, double fbest, double p_12)
{
int M = t.rows();
int N = x.rows();
CGppe gnew= CGppe(new CovSEard(),new CovSEard());
VectorXd idx_global_1, idx_global_2;
MatrixXd tstar = t.row(M-1);
double p_21, mei_12, mei_21;
p_21 = 1. - p_12;
train_pairs(M-1)=MatAdd(train_pairs(M-1),test_pair);
compute_global_index(idx_global_1, idx_global_2, train_pairs, N);
unique(idx_global, idx_global_1, idx_global_2);
ind2sub(ind_x, ind_t, N, M, idx_global);
gnew.Approx_CGppe_Laplace( theta_x, theta_t, sigma,
t, x, train_pairs, idx_global, idx_global_1, idx_global_2, ind_t, ind_x, M, N);
mei_12 = gnew.maximum_expected_improvement(theta_t, theta_x, sigma, t, x, idx_global, ind_t, ind_x, tstar, N, fbest);
//dsp(mei_12,"mei12");
//recomputation
fliplr(test_pair);
train_pairs(M-1).bottomRows(1)=test_pair;
compute_global_index(idx_global_1, idx_global_2, train_pairs, N);
unique(idx_global, idx_global_1, idx_global_2);
ind2sub(ind_x, ind_t, N, M, idx_global);
gnew.Approx_CGppe_Laplace( theta_x, theta_t, sigma,
t, x, train_pairs, idx_global, idx_global_1, idx_global_2, ind_t, ind_x, M, N);
mei_21 = gnew.maximum_expected_improvement(theta_t, theta_x, sigma, t, x, idx_global, ind_t, ind_x, tstar, N, fbest);
return (p_12*mei_12 + p_21*mei_21) ;
}
void CGppe::Elicit( const VectorXd & theta_x, const VectorXd& theta_t, const double& sigma, const MatrixXd& train_t, const MatrixXd &x, TypePair & train_pairs
, const MatrixXd & test_t, int test_user_idx, MatrixXd idx_pairs, int Maxiter, const TypePair& Oracle , MatrixXd& F)
{
train_pairs.conservativeResize(train_pairs.rows()+1);
int N = x.rows();
int Mtrain = train_t.rows();
int M = Mtrain + 1;
int Npairs = idx_pairs.rows();
int Lgood;
VectorXd vrand, idx_good;
//VectorXd is_selected(Npairs);
Matrix<bool, Dynamic, 1> is_selected(Npairs);
is_selected.fill(false);
VectorXd loss = VectorXd::Zero(Maxiter + 1);
double loss_current;
VectorXd evoi(Npairs), ind_t, ind_x;
VectorXd idx_global_1, idx_global_2, idx_global;
compute_global_index(idx_global_1, idx_global_2, train_pairs, N);
unique(idx_global, idx_global_1, idx_global_2);
ind2sub(ind_x, ind_t, N, M, idx_global);
bool stop = false;
double foo, val;
int count = 0;
MatrixXd new_pair;
MatrixXd t;
VectorXd p_12(Npairs);
t.resize(M, train_t.cols());
t << train_t, test_t;
for (int iter = 0;iter <= Maxiter;iter++)
{
Approx_CGppe_Laplace( theta_x, theta_t, sigma,
t, x, train_pairs, idx_global, idx_global_1, idx_global_2, ind_t, ind_x, Mtrain, N);
Predictive_Utility_Distribution(t, test_t, N, idx_global );
//dsp(mustar,"mustar");
//dsp(varstar,"varstar");
std::ptrdiff_t best_item_idx;
foo = mustar.maxCoeff(&best_item_idx);
double fbest = get_fbest(N);
//dsp(fbest,"fbest");
MatrixXd test_pair;
for (int i = 0;i < Npairs;i++)
{
Predict_CGppe_Laplace(sigma, t, x, idx_global, ind_t, ind_x, t.row(M-1), idx_pairs.row(i));
p_12(i)=p;
}
for (int i = 0;i < Npairs;i++)
{
if (is_selected(i))
{
evoi(i) = INT_MIN;
continue;
}
test_pair = idx_pairs.row(i);
evoi(i) = expected_voi(theta_x, theta_t, sigma, t, x, train_pairs, idx_global, ind_t, ind_x, test_pair, fbest,p_12(i));
}
//dsp(evoi,"evoi");
std::ptrdiff_t query_idx;
val = evoi.maxCoeff(&query_idx);
idx_good = find(evoi, val);
//dsp(val,"val");
Lgood = idx_good.rows();
if ( Lgood > 1)
{
//vrand = randperm(Lgood);
cout<<"Solving clashes at random"<<endl;
//query_idx = idx_good(vrand(0));
query_idx = idx_good(0);
}
is_selected(query_idx) = true;
//dsp(query_idx,"queryidx");
new_pair = make_query_toydata(Oracle, query_idx, test_user_idx);
//adding the new pair
train_pairs(M-1)=MatAdd(train_pairs(M-1),new_pair);
compute_global_index(idx_global_1, idx_global_2, train_pairs, N);
unique(idx_global, idx_global_1, idx_global_2);
ind2sub(ind_x, ind_t, N, M, idx_global);
//Computes the loss of making a recommendation at this point
loss_query_toydata(loss_current, F, stop, test_user_idx, best_item_idx);
loss(iter)=loss_current;
count++;
cout << "Query " << count << "[" << new_pair(0) << " " << new_pair(1) << "] done, Recommended Item= " << best_item_idx << ", loss=" << loss(iter) << endl;
}
}
double_vector L0Smoothing_1D(double_vector data, int jump)
{
double lambda = 0.01, kappa = 2.0;
double_vector out(data.size());
Matrix SR(data.size(), 1);
for(int j = 0; j < 1; ++j)
{
for(int i = 0; i < data.size(); ++i)
{
SR(i, j) = data[i];
}
}
double betamax = 1;
Matrix fx(1, 2);
fx(0, 0) = 1;
fx(0, 1) = -1;
Matrix fy(2, 1);
fy(0, 0) = 1;
fy(1, 0) = -1;
Matrix sizeI2D(1, 2);
sizeI2D(0, 0) = data.size();
sizeI2D(0, 1) = 1;
Matrix2 otfFx = psf2otf(fx, sizeI2D);
Matrix2 otfFy = psf2otf(fy, sizeI2D);
Matrix otfFx2 = MatAbsPow2(otfFx);
Matrix otfFy2 = MatAbsPow2(otfFy);
Matrix2 Normin1R = fft2_1D(SR);
Matrix Denormin2 = otfFx2;
float beta = 2 * lambda;
while(beta < betamax)
{
float lb = lambda / beta;
Matrix Denormin = ZMatrix(data.size(), 1);
Denormin = beta * Denormin2;
MatAdd(Denormin, 1);
Matrix vR = Matdiff(SR, 1);
Matrix Pos2Sum = MatPow2(vR);
for(int j = 0; j < 1; ++j)
{
for(int i = 0; i < data.size(); ++i)
{
if(Pos2Sum(i, j) < lb)
{
vR(i, j) = 0;
}
}
}
Matrix Normin2R = Matdiffinv(vR, 1);
Matrix2 FSR = (Normin1R + fft2_1D(vR) * beta) / Denormin;
SR = ifft2_1D(FSR);
beta = beta * kappa;
printf(".");
for(uint i = 0; i < data.size(); ++i)
{
for(uint j = 0; j < 1; ++j)
{
out[i] = SR(i, j);
}
}
}
return out;
}
void ParticleParticlePropagator<HartreeFock<MatsT, IntsT>>::formLinearTrans_direct_impl(
MPI_Comm c, RC_coll<U> x){
SingleSlater<MatsT,IntsT> &ss = dynamic_cast<SingleSlater<MatsT,IntsT>&>(*this->ref_);
bool doA = this->tdaOp == PP_A;
bool doOcc = not this->genSettings.doTDA or this->tdaOp == PP_C;
const size_t tdOffSet = this->genSettings.doTDA ? 0 : this->aDim_;
const size_t N = this->nSingleDim_ ;
const size_t chunk = 600;
#if 1
/****************************/
size_t NB = ss.aoints.basisSet().nBasis;
size_t NO = ss.nOA;
MatsT* MMat = this->memManager_.template malloc<MatsT>(NB*NB);
MatsT* JMMat = this->memManager_.template malloc<MatsT>(NB*NB);
MatsT* KMMat = this->memManager_.template malloc<MatsT>(NB*NB);
MatsT* MO = ss.mo1;
size_t indmo1 = NO;
Gemm('N','C',NB,NB,NB,MatsT(1.),MO + NO*NB,NB,MO + NO*NB,NB,MatsT(0.),MMat,NB);
std::fill_n(JMMat,NB*NB,0.);
std::fill_n(KMMat,NB*NB,0.);
std::vector<TwoBodyContraction<MatsT>> in =
{
{ true, MMat,JMMat,true, COULOMB },
{ true, MMat,KMMat,true, EXCHANGE }
};
ss.aoints.twoBodyContract(c,in);
MatAdd('N','N',NB,NB,MatsT(1.),JMMat, NB, MatsT(-0.5), KMMat, NB, JMMat, NB);
Gemm('N','N',NB,NB,NB,MatsT(1.),JMMat,NB,MO ,NB,MatsT(0.),KMMat,NB);
Gemm('C','N',NB,NB,NB,MatsT(1.),MO ,NB,KMMat,NB,MatsT(0.),MMat ,NB);
/****************************/
#endif
for(auto &X : x) {
const size_t nVec = X.nVec;
if( X.AX ) std::fill_n(X.AX,N*nVec,0.);
for(size_t k = 0; k < nVec; k += chunk) {
MPI_Barrier(c); // Sync MPI Processes at begining of each batch of
// vectors
const size_t nDo = std::min( chunk, nVec - k);
auto *V_c = X.X + k*N;
auto *HV_c = X.AX + k*N;
bool scatter = not bool(X.X);
#ifdef CQ_ENABLE_MPI
scatter = mxx::any_of(scatter,c);
#endif
// Transform pp vector MO -> AO
auto cList = this->genSettings.doTDA ?
this->template ppTransitionVecMO2AO<U>(c,scatter,nDo,N,V_c) :
this->template ppTransitionVecMO2AO<U>(c,scatter,nDo,N,V_c,
V_c + tdOffSet);
ss.aoints.twoBodyContract(c,cList); // form G[V]
// Only finish transformation on root process
if( MPIRank(c) == 0 ) {
// Transform pp vector AO -> MO
if( this->genSettings.doTDA )
this->ppTransitionVecAO2MO(nDo,N,cList,HV_c);
else
this->ppTransitionVecAO2MO(nDo,N,cList,HV_c,HV_c + tdOffSet);
// Scale by diagonals
if( not this->genSettings.doTDA or doA )
this->ppEpsilonScale(true,false,false,nDo,N,V_c,HV_c);
if( doOcc )
this->ppEpsilonScale(true,false,true,nDo,N,V_c + tdOffSet,
HV_c + tdOffSet);
// SCF* reference
if( this->doStarRef ) {
const size_t NV_t = this->getNV1(this->doStarRef);
const size_t NV2_t = this->getNV2(this->doStarRef);
const size_t NO_t = this->getNO1(this->doStarRef);
const size_t NO2_t = this->getNO2(this->doStarRef);
const bool doLT = (this->ref_->nC == 2) or (this->spinSepProp != PP_AB);
auto bmax = [&](size_t a){ return doLT ? a : NV2_t; };
auto jmax = [&](size_t i){ return doLT ? i : NO2_t; };
for(auto iVec = 0; iVec < nDo; iVec++) {
auto * HV_cc = HV_c + iVec*N;
auto * V_cc = V_c + iVec*N;
for(auto a = 0ul, ab = 0ul; a < NV_t; a++ )
for(auto b = 0ul ; b < bmax(a); b++, ab++){
const size_t A = a + NO_t;
const size_t B = b + NO_t;
for(auto c = 0ul, cd = 0ul; c < NV_t; c++ )
for(auto d = 0ul ; d < bmax(c); d++, cd++){
const size_t C = c + NO_t;
const size_t D = d + NO_t;
if(a == c) HV_cc[ab] -= V_cc[cd] * MMat[B + D*NB];
if(b == d) HV_cc[ab] -= V_cc[cd] * MMat[A + C*NB];
if(a == d) HV_cc[ab] += V_cc[cd] * MMat[B + C*NB];
if(b == c) HV_cc[ab] += V_cc[cd] * MMat[A + D*NB];
}
}
for(auto i = 0ul, ij = this->aDim_; i < NO_t; i++ )
for(auto j = 0ul ; j < jmax(i); j++, ij++){
for(auto k = 0ul, kl = this->aDim_; k < NO_t; k++ )
for(auto l = 0ul ; l < jmax(k); l++, kl++){
if(i == k) HV_cc[ij] += V_cc[kl] * MMat[j + l*NB];
if(j == l) HV_cc[ij] += V_cc[kl] * MMat[i + k*NB];
if(i == l) HV_cc[ij] -= V_cc[kl] * MMat[j + k*NB];
if(j == k) HV_cc[ij] -= V_cc[kl] * MMat[i + l*NB];
}
}
}
}
}
// Free up transformation memory
this->memManager_.free(cList[0].X);
} // loop over vectors
} // loop over groups of vectors
};
cv::Mat L0Smoothing(cv::Mat Im, double lambda = 0.02, double kappa = 2.0)
{
cv::Mat out(Im.rows, Im.cols, CV_32FC3);
Matrix SR(Im.rows, Im.cols);
Matrix SG(Im.rows, Im.cols);
Matrix SB(Im.rows, Im.cols);
for(int j = 0; j < Im.cols; ++j)
{
for(int i = 0; i < Im.rows; ++i)
{
cv::Vec3f& v1 = Im.at<cv::Vec3f>(i, j);
SR(i, j) = v1[0];
SG(i, j) = v1[1];
SB(i, j) = v1[2];
}
}
double betamax = 1e5;
Matrix fx(1, 2);
fx(0, 0) = 1;
fx(0, 1) = -1;
Matrix fy(2, 1);
fy(0, 0) = 1;
fy(1, 0) = -1;
Matrix sizeI2D(1, 2);
sizeI2D(0, 0) = Im.rows;
sizeI2D(0, 1) = Im.cols;
Matrix2 otfFx = psf2otf(fx, sizeI2D);
Matrix2 otfFy = psf2otf(fy, sizeI2D);
Matrix otfFx2 = MatAbsPow2(otfFx);
Matrix otfFy2 = MatAbsPow2(otfFy);
Matrix2 Normin1R = fft2(SR);
Matrix2 Normin1G = fft2(SG);
Matrix2 Normin1B = fft2(SB);
Matrix Denormin2 = otfFx2 + otfFy2;
float beta = 2 * lambda;
int count = 1;
while(beta < betamax)
{
float lb = lambda / beta;
Matrix Denormin = beta * Denormin2;
MatAdd(Denormin, 1);
Matrix hR = Matdiff(SR, 2);
Matrix vR = Matdiff(SR, 1);
Matrix hG = Matdiff(SG, 2);
Matrix vG = Matdiff(SG, 1);
Matrix hB = Matdiff(SB, 2);
Matrix vB = Matdiff(SB, 1);
Matrix Pos2Sum = MatPow2(hR) + MatPow2(vR) +
MatPow2(hG) + MatPow2(vG) +
MatPow2(hB) + MatPow2(vB);
for(int j = 0; j < Im.cols; ++j)
{
for(int i = 0; i < Im.rows; ++i)
{
if(Pos2Sum(i, j) < lb)
{
hR(i, j) = 0;
vR(i, j) = 0;
hG(i, j) = 0;
vG(i, j) = 0;
hB(i, j) = 0;
vB(i, j) = 0;
}
}
}
Matrix Normin2R = Matdiffinv(hR, 2) + Matdiffinv(vR, 1);
Matrix Normin2G = Matdiffinv(hG, 2) + Matdiffinv(vG, 1);
Matrix Normin2B = Matdiffinv(hB, 2) + Matdiffinv(vB, 1);
Matrix2 FSR = (Normin1R + fft2(Normin2R) * beta) / Denormin;
Matrix2 FSG = (Normin1G + fft2(Normin2G) * beta) / Denormin;
Matrix2 FSB = (Normin1B + fft2(Normin2B) * beta) / Denormin;
SR = ifft2(FSR);
SG = ifft2(FSG);
SB = ifft2(FSB);
beta = beta * kappa;
printf(".");
for(uint i = 0; i < out.rows; ++i)
{
for(uint j = 0; j < out.cols; ++j)
{
cv::Vec3f& v1 = out.at<cv::Vec3f>(i, j);
v1[0] = SR(i, j);
v1[1] = SG(i, j);
v1[2] = SB(i, j);
}
}
cv::imshow("out", out);
char filename[100];
sprintf(filename, "o%02d.png", count++);
cv::Mat theout;
out.convertTo(theout, CV_8UC3, 255);
cv::imwrite(filename, theout);
cv::waitKey(1);
}
for(uint j = 0; j < out.cols; ++j)
{
for(uint i = 0; i < out.rows; ++i)
{
cv::Vec3f& v1 = out.at<cv::Vec3f>(i, j);
v1[0] = SR(i, j);
v1[1] = SG(i, j);
v1[2] = SB(i, j);
}
}
return out;
}
