Pikmin::Pikmin()
{
std::discrete_distribution<int> disc_dist {8,40,20,8,8,8,8};
color = Color(disc_dist(rng));
std::uniform_int_distribution<int> uni_dist(0, namelist.size() - 1);
name = namelist[uni_dist(rng)];
}
float perform_random_point_queries (SpatialIndex::ISpatialIndex * tree,
const SpatialIndex::Region & query_region,
const unsigned number_of_queries)
{
boost::mt11213b generator (42u);
const double x[3] = {0.0, 0.0, 0.0};
access_count_visitor v;
for (unsigned j = 0; j < number_of_queries; j++)
{
SpatialIndex::Point rnd_point (x, query_region.m_dimension);
for (size_t i = 0; i < query_region.m_dimension; i++)
{
boost::uniform_real<> uni_dist (query_region.m_pLow[i],
query_region.m_pHigh[i]);
boost::variate_generator<boost::mt11213b &,
boost::uniform_real<> > uni(generator, uni_dist);
rnd_point.m_pCoords[i] = uni();
}
assert (query_region.containsPoint (rnd_point));
v.new_query();
tree->pointLocationQuery (rnd_point, v);
}
v.print_stats();
return v.get_avg_io();
}
double HG_Random::get_random_01_value() {
// Define a uniform random number distribution which produces "double"
// values between 0 and 1 (0 inclusive, 1 exclusive).
boost::uniform_real<> uni_dist(0,1);
boost::variate_generator<HG_RandomGenerator_t&, boost::uniform_real<> > uni(HG_Random::random_generator, uni_dist);
return uni();
}
int main(){
//ROOT::Cintex::Cintex::Enable();
pool::POOLContext::loadComponent( "SEAL/Services/MessageService" );
pool::POOLContext::loadComponent("COND/Services/TBufferBlobStreamingService");
pool::POOLContext::setMessageVerbosityLevel( seal::Msg::Error );
pool::Placement place;
place.setDatabase("sqlite_file:strip.db", pool::DatabaseSpecification::PFN );
place.setContainerName("mySiStripNoisesRcd");
place.setTechnology(pool::POOL_RDBMS_HOMOGENEOUS_StorageType.type());
pool::IFileCatalog* fileCatalog = new pool::IFileCatalog;
fileCatalog->setWriteCatalog( "file:me.xml" );
fileCatalog->connect();
fileCatalog->start();
pool::IDataSvc* datasvc = pool::DataSvcFactory::instance( fileCatalog );
pool::DatabaseConnectionPolicy policy;
policy.setWriteModeForNonExisting( pool::DatabaseConnectionPolicy::CREATE );
policy.setWriteModeForExisting( pool::DatabaseConnectionPolicy::OVERWRITE);
datasvc->session().setDefaultConnectionPolicy( policy );
datasvc->transaction().start(pool::ITransaction::UPDATE);
mySiStripNoises* myobj = new mySiStripNoises;
unsigned int detidseed=1234;
unsigned int bsize=100;
unsigned int nAPV=2;
base_generator_type rng(42u);
boost::uniform_real<> uni_dist(0,1);
boost::variate_generator<base_generator_type&, boost::uniform_real<> > uni(rng, uni_dist);
for(unsigned int detid=detidseed; detid<(detidseed+bsize);detid++){
std::vector<short> theSiStripVector;
for(unsigned int strip=0; strip<128*nAPV; ++strip){
std::cout<<strip<<std::endl;
float noise = uni();;
myobj->setData(noise,theSiStripVector);
}
myobj->put(detid,theSiStripVector);
}
std::cout<<"about to build ref"<<std::endl;
pool::Ref< mySiStripNoises > simple(datasvc,myobj);
std::cout<<"about to mark write"<<std::endl;
simple.markWrite(place);
std::cout<<"about to commit"<<std::endl;
std::string t=simple.toString();
std::cout<<"token "<<t<<std::endl;
datasvc->transaction().commit();
std::cout<<"committed"<<std::endl;
datasvc->transaction().start(pool::ITransaction::READ);
std::cout<<"about to read back"<<std::endl;
pool::Ref< mySiStripNoises > p(datasvc,t);
unsigned int a=p->v_noises.size();
std::cout<<"size a "<<a<<std::endl;
unsigned int b=p->indexes.size();
std::cout<<"size b "<<b<<std::endl;
datasvc->transaction().commit();
datasvc->session().disconnectAll();
fileCatalog->commit();
fileCatalog->disconnect();
return 0;
}
void elastic_smooth_hinge_psdca::train(void) {
const double one_over_nlam_ = 1.0 / (num_ins_ * lambda_);
const double one_over_lam_ = 1.0 / lambda_;
int i = 0;
double delta_alpha_i = 0.0;
double alpha_i_old = 0.0;
std::default_random_engine g;
std::uniform_int_distribution<> uni_dist(0, num_ins_ - 1);
init_w_za_over_n();
calculate_duality_gap(true, false);
const auto ins_is_begin_it = std::begin(all_ins_index_);
auto random_it = std::next(ins_is_begin_it, uni_dist(g));
for (itr_ = 1; itr_ < max_iter_ && duality_gap_ > stop_criterion_; ++itr_) {
for (int ir = 0; ir < num_ins_; ++ir) {
random_it = std::next(ins_is_begin_it, uni_dist(g));
i = *random_it;
alpha_i_old = dual_var_[i];
delta_alpha_i =
(1.0 - gamma_ * alpha_i_old - y_[i] * (x_.row(i) * primal_var_)(0)) /
(gamma_ + zi_sq_[i] * one_over_nlam_);
delta_alpha_i =
std::max(-alpha_i_old, std::min(1.0 - alpha_i_old, delta_alpha_i));
dual_var_[i] += delta_alpha_i;
za_over_n_ += (y_[i] * delta_alpha_i * one_over_n_) * x_.row(i);
for (int j = 0; j < num_fea_; ++j) {
primal_var_[j] =
fsss::sign(one_over_lam_ * za_over_n_[j]) *
std::max(0.0, std::abs(one_over_lam_ * za_over_n_[j]) - 1.0);
}
}
if ((itr_ + 1) % frequency_cal_gap_ == 0) {
calculate_duality_gap(true, false);
// std::cout << itr_ << " optimization end gap : " << duality_gap_ << " "
// << primal_obj_value_ << ", " << dual_obj_value_ << std::endl;
}
}
}
// Make a random box inside the World Box with the given percentage Volume
void Box::randomBox(const Box& world, const float percentageVolume,Box& random)
{
bigSpaceUnit newVolume = volume(world)*percentageVolume/100;
spaceUnit dimensionInc = pow(newVolume,1.0/3.0) /2;
for (size_t i = 0; i < DIMENSION; i++)
{
boost::uniform_real<> uni_dist (world.low.Vector[i],world.high.Vector[i]);
boost::variate_generator<boost::mt11213b &,boost::uniform_real<> > uni(generator, uni_dist);
float center = uni();
random.low.Vector[i] = center-dimensionInc;
random.high.Vector[i] = center+dimensionInc;
}
}
Pill(std::random_device& rd)
{
std::uniform_int_distribution<decltype(s_)> uni_dist;
s_ = uni_dist(rd);
int resp = b32_ndigits_;
b32_str_[resp] = '\0';
// http://philzimmermann.com/docs/human-oriented-base-32-encoding.txt
static constexpr const char* const b32_charset =
"ybndrfg8ejkmcpqxot1uwisza345h769";
const unsigned char* os = reinterpret_cast<const unsigned char*>(&s_);
const unsigned char* osp = os + sizeof(s_);
unsigned long x = 0;
switch ((osp - os) % 5) {
case 0:
do {
x = *--osp;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
case 4:
x |= (static_cast<unsigned long>(*--osp)) << 3;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
case 3:
x |= (static_cast<unsigned long>(*--osp)) << 1;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
case 2:
x |= (static_cast<unsigned long>(*--osp)) << 4;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
case 1:
x |= (static_cast<unsigned long>(*--osp)) << 2;
b32_str_[--resp] = b32_charset[x % 32];
x /= 32;
b32_str_[--resp] = b32_charset[x];
} while (osp > os);
}
}
int SampleUniform (int min, int max, int seed)
{
// Create a Mersenne twister random number generator
// that is seeded once with #seconds since 1970
static mt19937 rng(static_cast<unsigned> (seed));
// select Gaussian probability distribution
uniform_int<> uni_dist(min, max);
// bind random number generator to distribution, forming a function
variate_generator<mt19937&, uniform_int<> > uniform_sampler(rng, uni_dist);
// sample from the distribution
return uniform_sampler();
}
AnyType uniform_vector::run(AnyType & args)
{
int dim = args[0].getAs<int>();
double min_ = args[1].getAs<double>();
double max_ = args[2].getAs<double>();
int seed = args[3].getAs<int>();
if (dim < 1) {
throw std::invalid_argument("invalid argument - dim should be positive");
}
ColumnVector res(dim);
boost::minstd_rand generator(seed);
boost::uniform_real<> uni_dist(min_, max_);
boost::variate_generator<boost::minstd_rand&, boost::uniform_real<> > uni(generator, uni_dist);
for (int i = 0; i < dim; i++){
res(i) = (double)uni();
}
return res;
}
int main()
{
/* Quick hack for Dominic should be removed later, has nothing to do with 2dx_S
int n = 20;
int r_inner = 4;
int r_outer = 9;
SingleParticle2dx::real_array2d_type data2d = SingleParticle2dx::real_array2d_type(boost::extents[n][n]);
for (int i=0; i<n; i++)
{
for (int j=0; j<n; j++)
{
double r = sqrt( (i-n/2)*(i-n/2) + (j-n/2)*(j-n/2) );
//if ( (r>r_inner) && (r<r_outer) )
if ( (r<r_outer) )
{
data2d[i][j] = 1;
}
else
{
data2d[i][j] = 0;
}
}
}
SingleParticle2dx::Utilities::MRCFileIO::writeToMrc(&data2d, "scheibe.mrc");
return 0;
*/
boost::uniform_real<> uni_dist(-1,1);
boost::variate_generator<boost::mt19937, boost::uniform_real<> > generator(boost::mt19937(time(0)), uni_dist );
SingleParticle2dx::ConfigContainer* config = SingleParticle2dx::ConfigContainer::Instance();
config->setParticleSize(n);
SingleParticle2dx::DataStructures::Projection2d proj(n,n);
std::vector<SingleParticle2dx::DataStructures::Orientation*> orient_vec;
std::vector<std::string> name_vec;
orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(0,0,0));
name_vec.push_back("test_0_0_0.mrc");
// orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(0,0,45));
// name_vec.push_back("test_0_0_45.mrc");
// orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(0,30,0));
// name_vec.push_back("test_0_30_0.mrc");
// orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(0,30,45));
// name_vec.push_back("test_0_30_45.mrc");
// orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(30,45,0));
// name_vec.push_back("test_30_45_0.mrc");
// orient_vec.push_back(new SingleParticle2dx::DataStructures::Orientation(30,45,30));
// name_vec.push_back("test_30_45_45.mrc");
SingleParticle2dx::real_array3d_type protein = SingleParticle2dx::real_array3d_type(boost::extents[2*dh+2*offset+1][2*dh+2*offset+1][2*dh+2*offset+1]);
SingleParticle2dx::real_array3d_type data3d = SingleParticle2dx::real_array3d_type(boost::extents[n][n][n]);
generateObject(dh+offset, dh+offset, dh+offset, protein);
SingleParticle2dx::Utilities::MRCFileIO::writeToMrc(&protein, "protein.mrc");
SingleParticle2dx::DataStructures::Reconstruction3d rec(n,n,n);
for (int k=0; k<static_cast<int>(orient_vec.size()); k++)
{
std::cout << "Generate model " << k+1 << "/" << orient_vec.size() << std::endl;
SingleParticle2dx::Utilities::DataContainerFunctions::resetData(&data3d);
for(int i=lat; i<(n-lat); i+=lat)
{
for(int j=lat; j<(n-lat); j+=lat)
{
insertObject(i, j, n/2, data3d, protein, generator);
}
}
std::cout << "projecting down" << std::endl;
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
for(int k=0; k<i; k++)
{
float aux = data3d[i][j][k];
data3d[i][j][k] = data3d[k][j][i];
data3d[k][j][i] = aux;
}
}
}
rec.setFourierSpaceData(data3d);
rec.setProjectionMethod(4);
SingleParticle2dx::DataStructures::ParticleContainer dummy_container;
rec.forceProjectionPreparation(dummy_container);
rec.writeToFile("test3d.mrc");
int tilt = 0;
SingleParticle2dx::DataStructures::Orientation o(0, tilt, -90);
rec.calculateProjection(o, proj);
proj.writeToFile("proj_" + SingleParticle2dx::Utilities::StringFunctions::TtoString(tilt) + ".mrc" );
SingleParticle2dx::DataStructures::Orientation o2(90, 30, -180);
rec.calculateProjection(o2, proj);
proj.writeToFile("proj_" + SingleParticle2dx::Utilities::StringFunctions::TtoString(30) + ".mrc" );
}
rec.writeToFile( "test_syn.mrc" );
return 0;
}
void elastic_smooth_hinge_psdca::train_sfs3(const bool dynamic) {
const double one_over_nlam_ = 1.0 / (num_ins_ * lambda_);
const double one_over_lam_ = 1.0 / lambda_;
int i = 0;
double delta_alpha_i = 0.0;
double alpha_i_old = 0.0;
double yi = 0.0;
init_w_za_over_n();
calculate_duality_gap(true, false);
if (duality_gap_ <= stop_criterion_)
return;
double gap_pre = duality_gap_;
int pre_sfs_itr = 1;
if (!dynamic) {
sfs3(true);
}
int nss_size = nss_index_.size();
std::vector<std::uniform_int_distribution<>> uni_distri;
std::uniform_int_distribution<> uni_dist(0, nss_size - 1);
uni_distri.push_back(uni_dist);
auto ins_is_begin_it = std::begin(nss_index_);
std::default_random_engine g;
auto random_it = std::next(ins_is_begin_it, uni_distri[0](g));
for (itr_ = 1; itr_ < max_iter_ && duality_gap_ > stop_criterion_; ++itr_) {
for (int ir = 0; ir < num_ins_; ++ir) {
random_it = std::next(ins_is_begin_it, uni_distri[0](g));
i = *random_it;
alpha_i_old = dual_var_[i];
yi = y_[i];
delta_alpha_i =
(1.0 - gamma_ * alpha_i_old - yi * (x_.row(i) * primal_var_)(0)) /
(gamma_ + zi_sq_[i] * one_over_nlam_);
delta_alpha_i =
std::max(-alpha_i_old, std::min(1.0 - alpha_i_old, delta_alpha_i));
dual_var_[i] += delta_alpha_i;
za_over_n_ += (yi * delta_alpha_i * one_over_n_) * x_.row(i);
for (auto &&j : nfs_index_) {
primal_var_[j] =
fsss::sign(one_over_lam_ * za_over_n_[j]) *
std::max(0.0, std::abs(one_over_lam_ * za_over_n_[j]) - 1.0);
}
}
if (itr_ % frequency_cal_gap_ == 0) {
calculate_duality_gap(true, false);
if (duality_gap_ < stop_criterion_)
return;
if ((duality_gap_ / gap_pre < frequency_sfs3_ || itr_ <= 2) && dynamic) {
gap_pre = duality_gap_;
pre_sfs_itr = itr_;
sfs3(false);
if (nss_index_.size() == 0)
return;
ins_is_begin_it = std::begin(nss_index_);
std::uniform_int_distribution<> u_d(0, nss_index_.size() - 1);
uni_distri[0] = u_d;
}
}
}
}
int testSQLiteDatabaseConnection()
{
SQLiteDatabaseConnection connection;
QFile file("sqlitetest.db");
std::cerr << "Removing database test file \"sqlitetest.db\"..." << std::endl;
if (file.exists())
file.remove();
std::cerr << "Opening \"sqlitetest.db\"..." << std::endl;
connection.open("sqlitetest.db");
CHECK(connection.isDBOpen());
std::cerr << "Closing database..." << std::endl;
connection.close();
CHECK(!connection.isDBOpen());
std::cerr << "Reopening \"sqlitetest.db\"..." << std::endl;
connection.open("sqlitetest.db");
CHECK(connection.isDBOpen());
RoutingNode node(25, 51.0, 7.0);
std::cerr << "Save Node..." << std::endl;
CHECK(connection.saveNode(node));
node = RoutingNode(26, 51.5, 7.5);
CHECK(connection.saveNode(node));
CHECK(*connection.getNodeByID(26) == node);
CHECK(*connection.getNodeByID(RoutingNode::convertIDToLongFormat(26)) == node);
RoutingEdge edge(45, 25, 26);
std::cerr << "Save Edge..." << std::endl;
edge.setCycleBarrier(true);
edge.setCyclewayType(5);
CHECK(connection.saveEdge(edge, "Teststraße"));
CHECK_EQ_TYPE(connection.getStreetName(edge), "Teststraße", QString);
edge = RoutingEdge(46, 26, 25);
CHECK(connection.saveEdge(edge));
GPSPosition min(50.0, 6.0);
GPSPosition max(52.0, 8.0);
QVector<boost::shared_ptr<RoutingNode> > list = connection.getNodes(min, max);
CHECK(!list.isEmpty());
CHECK(list.size() == 2);
std::cerr << "Node 0 from DB: " << *(list[0]) << std::endl;
std::cerr << "Node 1 from DB: " << *(list[1]) << std::endl;
CHECK((*list[0] == node) || (*list[1] == node));
boost::minstd_rand generator(42u);
boost::uniform_real<> uni_dist(50, 52);
boost::variate_generator<boost::minstd_rand&, boost::uniform_real<> > uni(generator, uni_dist);
std::cerr << "Inserting 10000 Nodes within one transaction..." << std::endl;
bool successInsertManyNodes = true;
CHECK(connection.beginTransaction());
for (int i=0; i<10000; i++)
{
node = RoutingNode(i + 100, uni(), uni() - (51.0 - 7.0));
successInsertManyNodes = successInsertManyNodes && connection.saveNode(node);
}
CHECK(successInsertManyNodes);
CHECK(connection.endTransaction());
std::cerr << "Hier erwartet: Resultcode 19 (-> Constraint failed)" << std::endl;
CHECK(!connection.saveNode(node));
boost::shared_ptr<RoutingEdge> dbEdge(connection.getEdgeByEdgeID(46));
CHECK_EQ(edge, *dbEdge);
QVector<boost::shared_ptr<RoutingEdge> > edgeList;
edgeList = connection.getEdgesByStartNodeID(26);
CHECK_EQ(edge, *edgeList[0]);
edgeList = connection.getEdgesByStartNodeID(26);
CHECK_EQ(edge, *edgeList[0]);
edgeList = connection.getEdgesByEndNodeID(25);
CHECK_EQ(edge, *edgeList[0]);
edgeList = connection.getEdgesByEndNodeID(25);
CHECK_EQ(edge, *edgeList[0]);
std::cerr << "Inserting 10000 Edges within one transaction..." << std::endl;
bool successInsertManyEdges = true;
CHECK(connection.beginTransaction());
for (int i=0; i<10000; i++)
{
edge = RoutingEdge(i + 100, i+99, i+100);
successInsertManyEdges = successInsertManyEdges && connection.saveEdge(edge);
}
CHECK(successInsertManyEdges);
CHECK(connection.endTransaction());
std::cerr << "Hier erwartet: Resultcode 19 (-> Constraint failed)" << std::endl;
CHECK(!connection.saveEdge(edge));
edgeList = connection.getEdgesByStartNodeID(99);
CHECK(!edgeList.isEmpty());
edgeList = connection.getEdgesByStartNodeID(100);
CHECK(!edgeList.isEmpty());
CHECK(connection.beginTransaction());
CHECK(connection.deleteEdge(99, 100));
CHECK(connection.deleteEdge(100, 101));
CHECK(connection.endTransaction());
edgeList = connection.getEdgesByStartNodeID(99);
CHECK(edgeList.isEmpty());
edgeList = connection.getEdgesByStartNodeID(100);
CHECK(edgeList.isEmpty());
return EXIT_SUCCESS;
}
void elastic_soft_insensitive_psdca::train_ss(const bool dynamic) {
int i = 0;
double yi = 0.0;
double delta_alpha_i = 0.0, pdelta_alpha_i = 0.0, mdelta_alpha_i = 0.0,
delta_denominator = 0.0;
double alpha_i_old = 0.0;
const double one_over_nlam_ = 1.0 / (num_ins_ * lambda_);
const double one_over_lam_ = 1.0 / lambda_;
init_w_za_over_n();
calculate_duality_gap(true, false);
if (duality_gap_ <= stop_criterion_)
return;
double gap_old = duality_gap_;
double gap_pre = duality_gap_;
if (!dynamic)
initial_safe_feature_screen(true);
int nss_size = nss_index_.size();
std::vector<std::uniform_int_distribution<>> uni_distri;
std::uniform_int_distribution<> uni_dist(0, nss_size - 1);
uni_distri.push_back(uni_dist);
auto ins_is_begin_it = std::begin(nss_index_);
std::default_random_engine g;
auto random_it = std::next(ins_is_begin_it, uni_distri[0](g));
for (itr_ = 1; itr_ < max_iter_ && duality_gap_ > stop_criterion_; ++itr_) {
if (nss_size == 0 || nfs_index_.size() == 0)
return;
for (int ir = 0; ir < num_ins_; ++ir) {
random_it = std::next(ins_is_begin_it, uni_distri[0](g));
i = *random_it;
yi = y_[i];
alpha_i_old = dual_var_[i];
delta_denominator = 1.0 / (gamma_ + zi_sq_[i] * one_over_nlam_);
delta_alpha_i = delta_denominator * (yi - gamma_ * alpha_i_old -
(x_.row(i) * primal_var_)(0));
pdelta_alpha_i = delta_alpha_i + epsilon_ * delta_denominator;
mdelta_alpha_i = delta_alpha_i - epsilon_ * delta_denominator;
if (-pdelta_alpha_i > alpha_i_old) {
pdelta_alpha_i = std::max(-1.0 - alpha_i_old,
std::min(1.0 - alpha_i_old, pdelta_alpha_i));
dual_var_[i] += pdelta_alpha_i;
if (std::abs(pdelta_alpha_i) > 0.0)
za_over_n_ += (pdelta_alpha_i * one_over_n_) * x_.row(i);
} else if (-mdelta_alpha_i < alpha_i_old) {
mdelta_alpha_i = std::max(-1.0 - alpha_i_old,
std::min(1.0 - alpha_i_old, mdelta_alpha_i));
dual_var_[i] += mdelta_alpha_i;
if (std::abs(mdelta_alpha_i) > 0.0)
za_over_n_ += (mdelta_alpha_i * one_over_n_) * x_.row(i);
} else {
dual_var_[i] = 0.0;
if (std::abs(alpha_i_old) > 0.0)
za_over_n_ -= (alpha_i_old * one_over_n_) * x_.row(i);
}
for (auto &&j : nfs_index_) {
primal_var_[j] =
fsss::sign(one_over_lam_ * za_over_n_[j]) *
std::max(0.0, std::abs(one_over_lam_ * za_over_n_[j]) - 1.0);
}
}
if (itr_ % frequency_cal_gap_ == 0) {
calculate_duality_gap(true, false);
if ((duality_gap_ / gap_old < frequency_sfs3_ || itr_ < 2) && dynamic) {
gap_old = duality_gap_;
initial_safe_sample_screen(true);
if (nss_index_.size() == 0)
return;
ins_is_begin_it = std::begin(nss_index_);
std::uniform_int_distribution<> u_d(0, nss_index_.size() - 1);
uni_distri[0] = u_d;
} else if (std::abs(gap_pre - duality_gap_) < 0.1 * stop_criterion_ &&
dynamic) {
inverse_screen();
if ((sam_screening_index_.first.size() +
sam_screening_index_.second.size() + num_inv_sam_scr_) <
screening_end_rate_ * num_ins_) {
safe_sample_screen(true);
if (nss_index_.size() == 0)
return;
ins_is_begin_it = std::begin(nss_index_);
std::uniform_int_distribution<> u_d(0, nss_index_.size() - 1);
uni_distri[0] = u_d;
}
}
gap_pre = duality_gap_;
}
// std::cout << itr_ << " optimization end gap: " << duality_gap_ << " "
// << primal_obj_value_ << ", dov " << dual_obj_value_ << " "
// << num_fea_ - w_nnz_index_.size() << " "
// << sam_screening_index_.second.size() << " "
// << sam_screening_index_.first.size() << std::endl;
}
}
Eigen::VectorXd l2r_l1hinge_spdc::train_warm_start(const Eigen::VectorXd &alp) {
set_alpha(alp);
alpha_ = Eigen::VectorXd::Constant(num_ins_, C);
// set_w_by_alpha(alpha_);
double alpha_old = 0.0;
std::default_random_engine g;
std::uniform_int_distribution<> uni_dist(0, num_ins_ - 1);
const auto ins_is_begin_it = std::begin(active_index_);
w_ = Eigen::VectorXd::Zero(num_fea_);
spdc_w_ = w_;
auto random_it = std::next(ins_is_begin_it, uni_dist(g));
gamma_ = 0.1;
double tau_ = std::sqrt(gamma_ / (1.0 * (1.0 / C))) / R_;
double sigma_ = std::sqrt(((1.0 / C) * 1.0) / gamma_) / R_;
double theta_ =
1.0 - 1.0 / ((1.0 / C) + R_ * std::sqrt((1.0 / C) / (1.0 * gamma_)));
// double tau_ = std::sqrt(1.0) / (2.0 * R_);
// double sigma_ = std::sqrt(1.0 / 1.0) / (2.0 * R_);
// double theta_ = 1.0 - 1.0 / (1.0 + (R_ / gamma_) * std::sqrt(1.0 / 1.0));
const double sig_gam = -sigma_ * gamma_ - 1.0;
int i = 0, itr_ = 0;
double delta_alpha_i = 0.0, yi = 0.0, beta_i = 0.0, alpha_i_new = 0.0,
eta = 0.0;
Eigen::VectorXd delta_v(num_fea_), w_new(num_fea_);
calculate_duality_gap(true, true);
std::cout << tau_ << " " << sigma_ << " " << theta_ << " " << R_ << std::endl;
std::cout << " start optimization " << max_iteration << std::endl;
for (itr_ = 1; itr_ < max_iteration && duality_gap_ > 1e-6; ++itr_) {
for (int ir = 0; ir < num_ins_; ++ir) {
random_it = std::next(ins_is_begin_it, uni_dist(g));
i = *random_it;
yi = y_[i];
// beta_i = -(sigma_ * (yi * (x_.row(i) * spdc_w_)(0) - 1.0)) + alpha_[i];
beta_i = (sigma_ * (yi * (x_.row(i) * spdc_w_)(0) - 1.0) - alpha_[i]) /
(sig_gam);
alpha_i_new = std::min(C, std::max(0.0, beta_i));
delta_alpha_i = alpha_i_new - alpha_[i];
alpha_[i] = alpha_i_new;
delta_v = (yi * delta_alpha_i) * x_.row(i);
// w_new = (1.0 / (1.0 + tau_)) * (w_ - tau_ * (za_ - delta_v));
for (int j = 0; j < num_fea_; ++j) {
eta = (1.0 / (1.0 + tau_)) * (w_[j] + tau_ * (za_[j] + delta_v[j]));
spdc_w_[j] = eta + theta_ * (eta - w_[j]);
w_[j] = eta;
}
// spdc_w_ = w_new + theta_ * (w_new - w_);
// w_ = w_new;
// for (srm_iit it(x_, i); it; ++it)
// za_[it.index()] += delta_v[it.index()];
za_ += delta_v;
}
// if (itr_) {
calculate_duality_gap(true, true);
std::cout << itr_ << " optimization end gap : " << duality_gap_ << " "
<< primal_obj_value_ << " " << dual_obj_value_ << std::endl;
}
std::cout << itr_ << " optimization end gap : " << duality_gap_ << " "
<< primal_obj_value_ << " " << dual_obj_value_ << std::endl;
std::cout << w_.transpose() << std::endl;
return w_;
}
// Random double from [0,1)
double r01(boost::mt19937& rng) {
boost::uniform_real<> uni_dist(0, 1);
boost::variate_generator<boost::mt19937&, boost::uniform_real<> > uni(rng, uni_dist);
return uni();
}
int main()
{
// Define a random number generator and initialize it with a reproducible
// seed.
base_generator_type generator(42);
std::cout << "10 samples of a uniform distribution in [0..1):\n";
// Define a uniform random number distribution which produces "double"
// values between 0 and 1 (0 inclusive, 1 exclusive).
boost::uniform_real<> uni_dist(0,1);
boost::variate_generator<base_generator_type&, boost::uniform_real<> > uni(generator, uni_dist);
std::cout.setf(std::ios::fixed);
// You can now retrieve random numbers from that distribution by means
// of a STL Generator interface, i.e. calling the generator as a zero-
// argument function.
for(int i = 0; i < 10; i++)
std::cout << uni() << '\n';
/*
* Change seed to something else.
*
* Caveat: std::time(0) is not a very good truly-random seed. When
* called in rapid succession, it could return the same values, and
* thus the same random number sequences could ensue. If not the same
* values are returned, the values differ only slightly in the
* lowest bits. A linear congruential generator with a small factor
* wrapped in a uniform_smallint (see experiment) will produce the same
* values for the first few iterations. This is because uniform_smallint
* takes only the highest bits of the generator, and the generator itself
* needs a few iterations to spread the initial entropy from the lowest bits
* to the whole state.
*/
generator.seed(static_cast<unsigned int>(std::time(0)));
std::cout << "\nexperiment: roll a die 10 times:\n";
// You can save a generator's state by copy construction.
base_generator_type saved_generator = generator;
// When calling other functions which take a generator or distribution
// as a parameter, make sure to always call by reference (or pointer).
// Calling by value invokes the copy constructor, which means that the
// sequence of random numbers at the caller is disconnected from the
// sequence at the callee.
experiment(generator);
std::cout << "redo the experiment to verify it:\n";
experiment(saved_generator);
// After that, both generators are equivalent
assert(generator == saved_generator);
// as a degenerate case, you can set min = max for uniform_int
boost::uniform_int<> degen_dist(4,4);
boost::variate_generator<base_generator_type&, boost::uniform_int<> > deg(generator, degen_dist);
std::cout << deg() << " " << deg() << " " << deg() << std::endl;
{
// You can save the generator state for future use. You can read the
// state back in at any later time using operator>>.
std::ofstream file("rng.saved", std::ofstream::trunc);
file << generator;
}
return 0;
}
void elastic_soft_insensitive_psdca::train(void) {
int i = 0;
double yi = 0.0;
double delta_alpha_i = 0.0, pdelta_alpha_i = 0.0, mdelta_alpha_i = 0.0,
delta_denominator = 0.0;
double alpha_i_old = 0.0;
const double one_over_nlam_ = 1.0 / (num_ins_ * lambda_);
const double one_over_lam_ = 1.0 / lambda_;
std::default_random_engine g;
std::uniform_int_distribution<> uni_dist(0, num_ins_ - 1);
init_w_za_over_n();
calculate_duality_gap(true, false);
const auto ins_is_begin_it = std::begin(all_ins_index_);
auto random_it = std::next(ins_is_begin_it, uni_dist(g));
for (itr_ = 1; itr_ < max_iter_ && duality_gap_ > stop_criterion_; ++itr_) {
for (int ir = 0; ir < num_ins_; ++ir) {
random_it = std::next(ins_is_begin_it, uni_dist(g));
i = *random_it;
yi = y_[i];
alpha_i_old = dual_var_[i];
delta_denominator = 1.0 / (gamma_ + zi_sq_[i] * one_over_nlam_);
delta_alpha_i = delta_denominator * (yi - gamma_ * alpha_i_old -
(x_.row(i) * primal_var_)(0));
pdelta_alpha_i = delta_alpha_i + epsilon_ * delta_denominator;
mdelta_alpha_i = delta_alpha_i - epsilon_ * delta_denominator;
if (-pdelta_alpha_i > alpha_i_old) {
pdelta_alpha_i = std::max(-1.0 - alpha_i_old,
std::min(1.0 - alpha_i_old, pdelta_alpha_i));
dual_var_[i] += pdelta_alpha_i;
if (std::abs(pdelta_alpha_i) > 0.0)
za_over_n_ += (pdelta_alpha_i * one_over_n_) * x_.row(i);
} else if (-mdelta_alpha_i < alpha_i_old) {
mdelta_alpha_i = std::max(-1.0 - alpha_i_old,
std::min(1.0 - alpha_i_old, mdelta_alpha_i));
dual_var_[i] += mdelta_alpha_i;
if (std::abs(mdelta_alpha_i) > 0.0)
za_over_n_ += (mdelta_alpha_i * one_over_n_) * x_.row(i);
} else {
dual_var_[i] = 0.0;
if (std::abs(alpha_i_old) > 0.0)
za_over_n_ -= (alpha_i_old * one_over_n_) * x_.row(i);
}
for (int j = 0; j < num_fea_; ++j) {
primal_var_[j] =
fsss::sign(one_over_lam_ * za_over_n_[j]) *
std::max(0.0, std::abs(one_over_lam_ * za_over_n_[j]) - 1.0);
}
}
if (itr_ % frequency_cal_gap_ == 0) {
calculate_duality_gap(true, false);
// std::cout << itr_ << " optimization end gap : " << duality_gap_ << " "
// << primal_obj_value_ << " " << dual_obj_value_ << std::endl;
}
}
}
