Skip to content

Commit 574c198

Browse files
evaleevevaleev
committed
[unit] CP use multiple tiles in rank mode + cleanup
1 parent f32d3b8 commit 574c198

File tree

3 files changed

+57
-66
lines changed

3 files changed

+57
-66
lines changed

‎src/TiledArray/cp/btas_cp.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ template <typename Tile, typename Policy>
3131
auto btas_cp_als(madness::World& world, const DistArray<Tile, Policy> Reference,
3232
long btas_cp_rank, TA::TiledRange1 rank_trange1,
3333
std::size_t decomp_world_rank = 0, double als_threshold = 1e-3,
34-
bool verbose = true) {
34+
bool verbose = false) {
3535
using tile_type = typename DistArray<Tile, Policy>::value_type::value_type;
3636
using BTAS_Tensor =
3737
btas::Tensor<tile_type, btas::DEFAULT::range, btas::varray<double>>;
@@ -114,7 +114,7 @@ template <typename Tile, typename Policy>
114114
auto btas_cp_rals(madness::World& world, DistArray<Tile, Policy> Reference,
115115
long btas_cp_rank, TA::TiledRange1 rank_trange1,
116116
std::size_t decomp_world_rank = 0,
117-
double als_threshold = 1e-3, bool verbose = true) {
117+
double als_threshold = 1e-3, bool verbose = false) {
118118
using BTAS_Tensor =
119119
btas::Tensor<typename Tile::value_type, btas::DEFAULT::range,
120120
btas::varray<typename Tile::value_type>>;

‎src/TiledArray/cp/cp.h

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -94,9 +94,8 @@ class CP {
9494
/// moving to @c rank else builds an efficient
9595
/// random guess with rank @c rank
9696
/// \param[in] rank Rank of the CP deccomposition
97-
/// \param[in] rank_block_size 0; What is the size of the blocks
98-
/// in the rank mode's TiledRange, will compute TiledRange1 inline.
99-
/// if 0 : rank_blocck_size = rank.
97+
/// \param[in] rank_block_size The target tile size of
98+
/// rank mode's range; if 0 will use \p rank as \p rank_block_size .
10099
/// \param[in] build_rank should CP approximation be built from rank 1
101100
/// or set.
102101
/// \param[in] epsilonALS 1e-3; the stopping condition for the ALS solver

‎tests/cp.cpp

Lines changed: 53 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,8 @@
3535
#include "TiledArray/cp/cp_als.h"
3636
#include "TiledArray/cp/cp_reconstruct.h"
3737

38-
const std::string __dirname = dirname(strdup(__FILE__));
38+
constexpr std::int64_t rank_tile_size = 10;
39+
constexpr bool verbose = false;
3940

4041
using namespace TiledArray;
4142

@@ -138,38 +139,17 @@ struct CPFixture : public TiledRangeFixture {
138139
};
139140

140141
template <typename TArrayT>
141-
TArrayT compute_cp(const TArrayT& T, size_t cp_rank) {
142+
TArrayT compute_cp(const TArrayT& T, size_t cp_rank, bool verbose = false) {
142143
cp::CP_ALS<typename TArrayT::value_type, typename TArrayT::policy_type> CPD(
143144
T);
144-
CPD.compute_rank(cp_rank, 80, false, 1e-3, true);
145+
CPD.compute_rank(cp_rank, rank_tile_size, false, 1e-3, verbose);
145146
return CPD.reconstruct();
146147
}
147-
// TiledArray::TiledRange1 compute_trange1(std::size_t range_size,
148-
// std::size_t target_block_size) {
149-
// if (range_size > 0) {
150-
// std::size_t nblocks =
151-
// (range_size + target_block_size - 1) / target_block_size;
152-
// auto dv = std::div((int) (range_size + nblocks - 1), (int) nblocks);
153-
// auto avg_block_size = dv.quot - 1, num_avg_plus_one = dv.rem + 1;
154-
// std::vector<std::size_t> hashmarks;
155-
// hashmarks.reserve(nblocks + 1);
156-
// auto block_counter = 0;
157-
// for(auto i = 0; i < num_avg_plus_one; ++i, block_counter +=
158-
// avg_block_size + 1){
159-
// hashmarks.push_back(block_counter);
160-
// }
161-
// for (auto i = num_avg_plus_one; i < nblocks; ++i, block_counter+=
162-
// avg_block_size) {
163-
// hashmarks.push_back(block_counter);
164-
// }
165-
// hashmarks.push_back(range_size);
166-
// return TA::TiledRange1(hashmarks.begin(), hashmarks.end());
167-
// } else
168-
// return TA::TiledRange1{};
169-
// }
170148

171149
BOOST_FIXTURE_TEST_SUITE(cp_suite, CPFixture)
172150

151+
const auto target_rel_error = std::sqrt(std::numeric_limits<double>::epsilon());
152+
173153
BOOST_AUTO_TEST_CASE(btas_cp_als) {
174154
// Make a tiled range with block size of 1
175155
TiledArray::TiledRange tr3, tr4, tr5;
@@ -192,11 +172,12 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
192172
&this->init_unit_tile<TensorD>);
193173
size_t cp_rank = 1;
194174
factors = cp::btas_cp_als(*GlobalFixture::world, b_dense, cp_rank,
195-
compute_trange1(cp_rank, 80), 0, 1e-3);
175+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
176+
verbose);
196177
auto b_cp = cp::reconstruct(factors);
197178
TArrayD diff;
198179
diff("a,b,c") = b_dense("a,b,c") - b_cp("a,b,c");
199-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
180+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
200181
BOOST_CHECK(accurate);
201182
}
202183
// order-4 test
@@ -207,12 +188,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
207188
&this->init_unit_tile<TensorD>);
208189
size_t cp_rank = 1;
209190
factors = cp::btas_cp_als(*GlobalFixture::world, b_dense, cp_rank,
210-
compute_trange1(cp_rank, 80), 0, 1e-3);
191+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
192+
verbose);
211193

212194
auto b_cp = cp::reconstruct(factors);
213195
TArrayD diff;
214196
diff("a,b,c,d") = b_dense("a,b,c,d") - b_cp("a,b,c,d");
215-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
197+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
216198
BOOST_CHECK(accurate);
217199
}
218200
// order-5 test
@@ -223,12 +205,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
223205
&this->init_unit_tile<TensorD>);
224206
size_t cp_rank = 1;
225207
factors = cp::btas_cp_als(*GlobalFixture::world, b_dense, cp_rank,
226-
compute_trange1(cp_rank, 80), 0, 1e-3);
208+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
209+
verbose);
227210

228211
auto b_cp = cp::reconstruct(factors);
229212
TArrayD diff;
230213
diff("a,b,c,d,e") = b_dense("a,b,c,d,e") - b_cp("a,b,c,d,e");
231-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
214+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
232215
BOOST_CHECK(accurate);
233216
}
234217

@@ -239,13 +222,14 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
239222
auto b_sparse = make_array<TSpArrayD>(*GlobalFixture::world, tr3,
240223
&this->init_rand_tile<TensorD>);
241224
size_t cp_rank = 77;
242-
factors = cp::btas_cp_als(*GlobalFixture::world, b_sparse, cp_rank,
243-
compute_trange1(cp_rank, 80), 0, 1e-3);
225+
factors =
226+
cp::btas_cp_als(*GlobalFixture::world, b_sparse, cp_rank,
227+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3);
244228

245229
auto b_cp = cp::reconstruct(factors);
246230
TSpArrayD diff;
247231
diff("a,b,c") = b_sparse("a,b,c") - b_cp("a,b,c");
248-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
232+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
249233
BOOST_CHECK(accurate);
250234
}
251235
// order-4 test
@@ -256,12 +240,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
256240
&this->init_unit_tile<TensorD>);
257241
size_t cp_rank = 1;
258242
factors = cp::btas_cp_als(*GlobalFixture::world, b_sparse, cp_rank,
259-
compute_trange1(cp_rank, 80), 0, 1e-3);
243+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
244+
verbose);
260245

261246
auto b_cp = cp::reconstruct(factors);
262247
TSpArrayD diff;
263248
diff("a,b,c,d") = b_sparse("a,b,c,d") - b_cp("a,b,c,d");
264-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
249+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
265250
BOOST_CHECK(accurate);
266251
}
267252
// order-5 test
@@ -272,7 +257,8 @@ BOOST_AUTO_TEST_CASE(btas_cp_als) {
272257
&this->init_unit_tile<TensorD>);
273258
size_t cp_rank = 1;
274259
factors = cp::btas_cp_als(*GlobalFixture::world, b_sparse, cp_rank,
275-
compute_trange1(cp_rank, 80), 0, 1e-3);
260+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
261+
verbose);
276262

277263
auto b_cp = cp::reconstruct(factors);
278264
TSpArrayD diff;
@@ -304,12 +290,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
304290
&this->init_unit_tile<TensorD>);
305291
size_t cp_rank = 1;
306292
factors = cp::btas_cp_rals(*GlobalFixture::world, b_dense, cp_rank,
307-
compute_trange1(cp_rank, 80), 0, 1e-3);
293+
compute_trange1(cp_rank, rank_tile_size), 0,
294+
1e-3, verbose);
308295

309296
auto b_cp = cp::reconstruct(factors);
310297
TArrayD diff;
311298
diff("a,b,c") = b_dense("a,b,c") - b_cp("a,b,c");
312-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
299+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
313300
BOOST_CHECK(accurate);
314301
}
315302
// order-4 test
@@ -320,12 +307,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
320307
&this->init_unit_tile<TensorD>);
321308
size_t cp_rank = 1;
322309
factors = cp::btas_cp_rals(*GlobalFixture::world, b_dense, cp_rank,
323-
compute_trange1(cp_rank, 80), 0, 1e-3);
310+
compute_trange1(cp_rank, rank_tile_size), 0,
311+
1e-3, verbose);
324312

325313
auto b_cp = cp::reconstruct(factors);
326314
TArrayD diff;
327315
diff("a,b,c,d") = b_dense("a,b,c,d") - b_cp("a,b,c,d");
328-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
316+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
329317
BOOST_CHECK(accurate);
330318
}
331319
// order-5 test
@@ -336,12 +324,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
336324
&this->init_unit_tile<TensorD>);
337325
size_t cp_rank = 1;
338326
factors = cp::btas_cp_rals(*GlobalFixture::world, b_dense, cp_rank,
339-
compute_trange1(cp_rank, 80), 0, 1e-3);
327+
compute_trange1(cp_rank, rank_tile_size), 0,
328+
1e-3, verbose);
340329

341330
auto b_cp = cp::reconstruct(factors);
342331
TArrayD diff;
343332
diff("a,b,c,d,e") = b_dense("a,b,c,d,e") - b_cp("a,b,c,d,e");
344-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
333+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
345334
BOOST_CHECK(accurate);
346335
}
347336

@@ -353,12 +342,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
353342
&this->init_rand_tile<TensorD>);
354343
size_t cp_rank = 77;
355344
factors = cp::btas_cp_rals(*GlobalFixture::world, b_sparse, cp_rank,
356-
compute_trange1(cp_rank, 80), 0, 1e-3);
345+
compute_trange1(cp_rank, rank_tile_size), 0,
346+
1e-3, verbose);
357347

358348
auto b_cp = cp::reconstruct(factors);
359349
TSpArrayD diff;
360350
diff("a,b,c") = b_sparse("a,b,c") - b_cp("a,b,c");
361-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
351+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
362352
BOOST_CHECK(accurate);
363353
}
364354
// order-4 test
@@ -369,12 +359,13 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
369359
&this->init_unit_tile<TensorD>);
370360
size_t cp_rank = 1;
371361
factors = cp::btas_cp_rals(*GlobalFixture::world, b_sparse, cp_rank,
372-
compute_trange1(cp_rank, 80), 0, 1e-3);
362+
compute_trange1(cp_rank, rank_tile_size), 0,
363+
1e-3, verbose);
373364

374365
auto b_cp = cp::reconstruct(factors);
375366
TSpArrayD diff;
376367
diff("a,b,c,d") = b_sparse("a,b,c,d") - b_cp("a,b,c,d");
377-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
368+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
378369
BOOST_CHECK(accurate);
379370
}
380371
// order-5 test
@@ -385,7 +376,8 @@ BOOST_AUTO_TEST_CASE(btas_cp_rals) {
385376
&this->init_unit_tile<TensorD>);
386377
size_t cp_rank = 1;
387378
factors = cp::btas_cp_als(*GlobalFixture::world, b_sparse, cp_rank,
388-
compute_trange1(cp_rank, 80), 0, 1e-3);
379+
compute_trange1(cp_rank, rank_tile_size), 0, 1e-3,
380+
verbose);
389381

390382
auto b_cp = cp::reconstruct(factors);
391383
TSpArrayD diff;
@@ -415,10 +407,10 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
415407
auto b_dense = make_array<TArrayD>(*GlobalFixture::world, tr3,
416408
&this->init_unit_tile<TensorD>);
417409
size_t cp_rank = 1;
418-
auto b_cp = compute_cp(b_dense, cp_rank);
410+
auto b_cp = compute_cp(b_dense, cp_rank, verbose);
419411
TArrayD diff;
420412
diff("a,b,c") = b_dense("a,b,c") - b_cp("a,b,c");
421-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
413+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
422414
BOOST_CHECK(accurate);
423415
}
424416
// order-4 test
@@ -427,11 +419,11 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
427419
auto b_dense = make_array<TArrayD>(*GlobalFixture::world, tr4,
428420
&this->init_unit_tile<TensorD>);
429421
size_t cp_rank = 1;
430-
auto b_cp = compute_cp(b_dense, cp_rank);
422+
auto b_cp = compute_cp(b_dense, cp_rank, verbose);
431423

432424
TArrayD diff;
433425
diff("a,b,c,d") = b_dense("a,b,c,d") - b_cp("a,b,c,d");
434-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
426+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
435427
BOOST_CHECK(accurate);
436428
}
437429
// order-5 test
@@ -441,11 +433,11 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
441433
auto b_dense = make_array<TArrayD>(*GlobalFixture::world, tr5,
442434
&this->init_unit_tile<TensorD>);
443435
size_t cp_rank = 1;
444-
auto b_cp = compute_cp(b_dense, cp_rank);
436+
auto b_cp = compute_cp(b_dense, cp_rank, verbose);
445437

446438
TArrayD diff;
447439
diff("a,b,c,d,e") = b_dense("a,b,c,d,e") - b_cp("a,b,c,d,e");
448-
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < 1e-10);
440+
bool accurate = (TA::norm2(diff) / TA::norm2(b_dense) < target_rel_error);
449441
BOOST_CHECK(accurate);
450442
}
451443

@@ -458,10 +450,10 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
458450
&this->init_rand_tile<TensorD>);
459451
b_sparse.truncate();
460452
size_t cp_rank = 77;
461-
auto b_cp = compute_cp(b_sparse, cp_rank);
453+
auto b_cp = compute_cp(b_sparse, cp_rank, verbose);
462454
TSpArrayD diff;
463455
diff("a,b,c") = b_sparse("a,b,c") - b_cp("a,b,c");
464-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
456+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
465457
BOOST_CHECK(accurate);
466458
}
467459
// order-4 test
@@ -472,10 +464,10 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
472464
&this->init_unit_tile<TensorD>);
473465
b_sparse.truncate();
474466
size_t cp_rank = 1;
475-
auto b_cp = compute_cp(b_sparse, cp_rank);
467+
auto b_cp = compute_cp(b_sparse, cp_rank, verbose);
476468
TSpArrayD diff;
477469
diff("a,b,c,d") = b_sparse("a,b,c,d") - b_cp("a,b,c,d");
478-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
470+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
479471
BOOST_CHECK(accurate);
480472
}
481473
// order-5 test
@@ -485,10 +477,10 @@ BOOST_AUTO_TEST_CASE(ta_cp_als) {
485477
auto b_sparse = make_array<TSpArrayD>(*GlobalFixture::world, tr5,
486478
&this->init_unit_tile<TensorD>);
487479
double cp_rank = 1;
488-
auto b_cp = compute_cp(b_sparse, cp_rank);
480+
auto b_cp = compute_cp(b_sparse, cp_rank, verbose);
489481
TSpArrayD diff;
490482
diff("a,b,c,d,e") = b_sparse("a,b,c,d,e") - b_cp("a,b,c,d,e");
491-
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < 1e-10);
483+
bool accurate = (TA::norm2(diff) / TA::norm2(b_sparse) < target_rel_error);
492484
BOOST_CHECK(accurate);
493485
}
494486
}

0 commit comments

Comments
 (0)