double Lasso(size_t m, size_t n) {
std::vector<T> A(m * n);
std::vector<T> b(m);
std::default_random_engine generator;
std::uniform_real_distribution<T> u_dist(static_cast<T>(0),
static_cast<T>(1));
std::normal_distribution<T> n_dist(static_cast<T>(0),
static_cast<T>(1));
for (unsigned int i = 0; i < m * n; ++i)
A[i] = n_dist(generator);
std::vector<T> x_true(n);
for (unsigned int i = 0; i < n; ++i)
x_true[i] = u_dist(generator) < static_cast<T>(0.8)
? static_cast<T>(0) : n_dist(generator) / static_cast<T>(std::sqrt(n));
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (unsigned int i = 0; i < m; ++i)
for (unsigned int j = 0; j < n; ++j)
b[i] += A[i * n + j] * x_true[j];
// b[i] += A[i + j * m] * x_true[j];
for (unsigned int i = 0; i < m; ++i)
b[i] += static_cast<T>(0.5) * n_dist(generator);
T lambda_max = static_cast<T>(0);
#ifdef _OPENMP
#pragma omp parallel for reduction(max : lambda_max)
#endif
for (unsigned int j = 0; j < n; ++j) {
T u = 0;
for (unsigned int i = 0; i < m; ++i)
//u += A[i * n + j] * b[i];
u += A[i + j * m] * b[i];
lambda_max = std::max(lambda_max, std::abs(u));
}
pogs::MatrixDense<T> A_('r', m, n, A.data());
pogs::PogsDirect<T, pogs::MatrixDense<T> > pogs_data(A_);
std::vector<FunctionObj<T> > f;
std::vector<FunctionObj<T> > g;
f.reserve(m);
for (unsigned int i = 0; i < m; ++i)
f.emplace_back(kSquare, static_cast<T>(1), b[i]);
g.reserve(n);
for (unsigned int i = 0; i < n; ++i)
g.emplace_back(kAbs, static_cast<T>(0.2) * lambda_max);
double t = timer<double>();
pogs_data.Solve(f, g);
return timer<double>() - t;
}
int main()
{
typedef Clustering<4, Point2D, EuclideanDistance> euclideanClustering;
typedef Clustering<4, Point2D, AnisotropicDistance> anisotropicClustering;
euclideanClustering eC;
anisotropicClustering aC;
eC.setup( 1.e-6, 100, false );
aC.setup( 1.e-6, 100, false );
AnisotropicDistance<Point2D>::tensor_T matrix;
matrix << 3, 1, 1, 3;
aC.getDistancePolicy().setTensor( matrix );
std::random_device rd;
std::mt19937 gen( rd() );
std::normal_distribution<> n_dist( 0.5, 0.3 );
euclideanClustering::centroidList_T centroids;
for( int iC = 0; iC < centroids.size(); iC++ )
{
centroids[iC] << n_dist( gen ), n_dist( gen );
}
// centroids[0] << -1., 0.5;
// centroids[1] << 2., 0.5;
eC.setInitialCentroids( centroids );
aC.setInitialCentroids( centroids );
euclideanClustering::objectList_T points( 1000 );
for( int iPoint = 0; iPoint < points.size(); iPoint++ )
{
points[iPoint] << n_dist( gen ), n_dist( gen );
}
// points[0] << 0., 0.;
// points[1] << 1., 0.;
// points[2] << 1., 1.;
// points[3] << 0., 1.;
// points[4] << 2., 0.;
// points[5] << 2., 1.;
eC.apply( points );
//aC.apply( points );
centroids = eC.getCentroids();
std::cout << "Centroids computed with euclidean norm:" << std::endl
<< "centroid 0:" << std::endl << centroids[0] << std::endl
<< "centroid 1:" << std::endl << centroids[1] << std::endl;
centroids = aC.getCentroids();
std::cout << "Centroids computed with anisotropic norm:" << std::endl
<< "centroid 0:" << std::endl << centroids[0] << std::endl
<< "centroid 1:" << std::endl << centroids[1] << std::endl;
//system("ffmpeg -i cluster%02d.png cluster.avi -r 1");
return 0;
}
double Logistic(size_t m, size_t n) {
std::vector<T> A(m * (n + 1));
std::vector<T> d(m);
std::vector<T> x(n + 1);
std::vector<T> y(m);
std::default_random_engine generator;
std::uniform_real_distribution<T> u_dist(static_cast<T>(0),
static_cast<T>(1));
std::normal_distribution<T> n_dist(static_cast<T>(0),
static_cast<T>(1));
for (unsigned int i = 0; i < m; ++i) {
for (unsigned int j = 0; j < n; ++j)
A[i * (n + 1) + j] = n_dist(generator);
A[i * (n + 1) + n] = 1;
}
std::vector<T> x_true(n + 1);
for (unsigned int i = 0; i < n; ++i)
x_true[i] = u_dist(generator) < 0.8 ? 0 : n_dist(generator) / n;
x_true[n] = n_dist(generator) / n;
#pragma omp parallel for
for (unsigned int i = 0; i < m; ++i) {
d[i] = 0;
for (unsigned int j = 0; j < n + 1; ++j)
// u += A[i + j * m] * x_true[j];
d[i] += A[i * n + j] * x_true[j];
}
for (unsigned int i = 0; i < m; ++i)
d[i] = 1 / (1 + std::exp(-d[i])) > u_dist(generator);
T lambda_max = static_cast<T>(0);
#pragma omp parallel for reduction(max : lambda_max)
for (unsigned int j = 0; j < n; ++j) {
T u = 0;
for (unsigned int i = 0; i < m; ++i)
// u += A[i * n + j] * (static_cast<T>(0.5) - d[i]);
u += A[i + j * m] * (static_cast<T>(0.5) - d[i]);
lambda_max = std::max(lambda_max, std::abs(u));
}
Dense<T, ROW> A_(A.data());
PogsData<T, Dense<T, ROW>> pogs_data(A_, m, n + 1);
pogs_data.x = x.data();
pogs_data.y = y.data();
pogs_data.f.reserve(m);
for (unsigned int i = 0; i < m; ++i)
pogs_data.f.emplace_back(kLogistic, 1, 0, 1, -d[i]);
pogs_data.g.reserve(n + 1);
for (unsigned int i = 0; i < n; ++i)
pogs_data.g.emplace_back(kAbs, static_cast<T>(0.5) * lambda_max);
pogs_data.g.emplace_back(kZero);
double t = timer<double>();
Pogs(&pogs_data);
return timer<double>() - t;
}
