Add support for calculating the permanent using the BBFG algorithm #267

maliasadi · 2021-07-28T21:02:16Z

Context:
Currently, The Walrus uses the Ryser's formula to calculate permanents of arbitrary matrices that has time-complexity of O(n 2^n) if it's implemented with Gray code ordering. Another useful permanent algorithm with the same complexity is through BBFG's formula that's introduced by David G. Glynn in"The permanent of a square matrix". This pull request adds both C++ and Python support for permanent calculation using the latter formula.

Description of the Change:

Implemented a templated version of the BBFG formula in C++. It's a sequential algorithm (nthreads=1) from "The permanent of a square matrix" by David G. Glynn with using Gray code ordering. This is added in the ./include/permanent.hpp.
Added two wrappers for Python integration (perm_BBFG_qp and perm_BBFG_cmplx) and one for the future parallel vs. serial integration (perm_BBFG).
Added tests to ./tests/libwalrus_unittest.cpp
Integrated algorithms in ./thewalrus/libwalrus.pyx
Added tests to ./thewalrus/tests/test_permanent.py for integrated python methods naming perm_BBFG, perm_BBFG_real and perm_BBFG_complex.
...

Benefits:
As @mlxd suggested, having both methods implemented will allow for performance and accuracy comparisons and trade-offs.

Possible Drawbacks:

Related GitHub Issues:
Issue #263 created by @mlxd

…BFG algorithm and Gray code ordering (XanaduAI#263)

maliasadi · 2021-07-28T22:21:03Z

A brief discussion on new algorithms in ./include/permanent.hpp:

My first implementation of BBFG algorithm is perm_BBFG_serial that is in fact my first understanding of this formula presented in "The permanent of a square matrix" with adding Gray code ordering support. In my second try to parallel the code, I realized that there are still some embarrassingly obvious optimizations there, so, I optimized my first implementation and name the new one perm_BBFG_serial2. I compare the performance of both BBFG algorithms with the Ryser's implementation (the permanent function) for n*n double random matrices with ntrials=10, nthreads=1 and g++ -O3:

[mat=20*20] BBFG_serial: 17ms
[mat=20*20] BBFG_serial2: 12ms
[mat=20*20] Ryser_permanent: 21ms

[mat=25*25] BBFG_serial: 544ms
[mat=25*25] BBFG_serial2: 442ms
[mat=25*25] Ryser_permanent: 818ms

[mat=30*30] BBFG_serial: 21182ms
[mat=30*30] BBFG_serial2: 18218ms
[mat=30*30] Ryser_permanent: 33242ms

[mat=31*31] BBFG_serial: 46229ms
[mat=31*31] BBFG_serial2: 38278ms
[mat=31*31] Ryser_permanent: 67662ms

[mat=32*32] BBFG_serial: 88446ms
[mat=32*32] BBFG_serial2: 74259ms
[mat=32*32] Ryser_permanent: 141167ms

Please, let me know what you think about further improvements.

thewalrus/_permanent.py

thewalrus/tests/test_permanent.py

mlxd

Nice work @maliasadi
Just a few questions and suggestions from my side.

include/permanent.hpp

maliasadi · 2021-08-01T05:16:20Z

Thank you @mlxd for the suggestions!

New benchmark comparing permanent algorithms:

[mat=20*20] BBFG_serial: 12ms
[mat=20*20] BBFG_serial2: 10ms
[mat=20*20] Ryser_permanent: 21ms

[mat=25*25] BBFG_serial: 471ms
[mat=25*25] BBFG_serial2: 420ms
[mat=25*25] Ryser_permanent: 821ms

[mat=30*30] BBFG_serial: 19510ms
[mat=30*30] BBFG_serial2: 16157ms
[mat=30*30] Ryser_permanent: 31629ms

[mat=31*31] BBFG_serial: 41823ms
[mat=31*31] BBFG_serial2: 35887ms
[mat=31*31] Ryser_permanent: 65591ms

[mat=32*32] BBFG_serial: 88514ms
[mat=32*32] BBFG_serial2: 71134ms
[mat=32*32] Ryser_permanent: 135052ms

[mat=35*35] BBFG_serial: 751871ms
[mat=35*35] BBFG_serial2: 732640ms
[mat=35*35] Ryser_permanent: 1391576ms

jakeffbulmer · 2021-08-05T10:33:19Z

Hi @maliasadi, I'd be interested to see if there are any numerical accuracy differences between the Ryser and BBFG algorithms. I have a feeling that BBFG may perform better. The simplest test for this I can think of is that the permant of an n x n all-ones matrix, M, should give n!, so computing |perm(M) - n!| / n! for different n should be interesting.

maliasadi · 2021-08-06T20:51:04Z

Hi @maliasadi, I'd be interested to see if there are any numerical accuracy differences between the Ryser and BBFG algorithms. I have a feeling that BBFG may perform better. The simplest test for this I can think of is that the permant of an n x n all-ones matrix, M, should give n!, so computing |perm(M) - n!| / n! for different n should be interesting.

Hi @jakeffbulmer, although both Ryser and BBFG are among "exact" algorithms and not statistical, like Markov Chain Monte Carlo algorithm for calculating permanent, that's a very good concern. Thanks for the proposed test formula! I gave it a try with these algorithms and the results are as follows. It seems that your feeling is right :)

n: 10	n!: 3628800
bbfg: 3.6288e+06	Ryser: 3.6288e+06
bbfg-diff: 0		Ryser-diff: 0
n: 11	n!: 39916800
bbfg: 3.99168e+07	Ryser: 3.99168e+07
bbfg-diff: 0		Ryser-diff: 0
n: 12	n!: 479001600
bbfg: 4.79002e+08	Ryser: 4.79002e+08
bbfg-diff: 0		Ryser-diff: 0
n: 13	n!: 6227020800
bbfg: 6.22702e+09	Ryser: 6.22702e+09
bbfg-diff: 0		Ryser-diff: 0
n: 14	n!: 87178291200
bbfg: 8.71783e+10	Ryser: 8.71783e+10
bbfg-diff: 0		Ryser-diff: 0
n: 15	n!: 1307674368000
bbfg: 1.30767e+12	Ryser: 1.30767e+12
bbfg-diff: 0		Ryser-diff: 0
n: 16	n!: 20922789888000
bbfg: 2.09228e+13	Ryser: 2.09228e+13
bbfg-diff: 0		Ryser-diff: 0
n: 17	n!: 355687428096000
bbfg: 3.55687e+14	Ryser: 3.55687e+14
bbfg-diff: 3.99136e-16	Ryser-diff: 2.8958e-13
n: 18	n!: 6402373705728000
bbfg: 6.40237e+15	Ryser: 6.40237e+15
bbfg-diff: 0		Ryser-diff: 3.56696e-12
n: 19	n!: 121645100408832000
bbfg: 1.21645e+17	Ryser: 1.21645e+17
bbfg-diff: 1.4011e-15	Ryser-diff: 1.34466e-11
n: 20	n!: 2432902008176640000
bbfg: 2.4329e+18	Ryser: 2.4329e+18
bbfg-diff: 1.31777e-15	Ryser-diff: 1.55759e-10

codecov · 2021-08-08T15:59:05Z

Codecov Report

Merging #267 (c03fabf) into master (ecb5aaa) will not change coverage.
The diff coverage is 100.00%.

@@            Coverage Diff            @@
##            master      #267   +/-   ##
=========================================
  Coverage   100.00%   100.00%           
=========================================
  Files           21        21           
  Lines         1418      1419    +1     
=========================================
+ Hits          1418      1419    +1

Impacted Files	Coverage Δ
thewalrus/__init__.py	`100.00% <100.00%> (ø)`
thewalrus/_permanent.py	`100.00% <100.00%> (ø)`

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update ecb5aaa...c03fabf. Read the comment docs.

jakeffbulmer · 2021-08-09T08:57:33Z

Hi @jakeffbulmer, although both Ryser and BBFG are among "exact" algorithms and not statistical, like Markov Chain Monte Carlo algorithm for calculating permanent, that's a very good concern. Thanks for the proposed test formula! I gave it a try with these algorithms and the results are as follows. It seems that your feeling is right :)

Thanks @maliasadi - that's exactly what I was hoping to see!

mlxd

Great job on this @maliasadi !
Nothing more to add on my side. We'll follow-up shortly.

maliasadi · 2021-08-10T14:03:07Z

@mlxd @nquesada: Could you please check and re-run ci/circleci: osx-wheels for me? This failed test may not be related to my changes.

nquesada · 2021-08-10T14:06:41Z

Hey @maliasadi : could you also add your name here: https://github.com/XanaduAI/thewalrus/blob/master/.github/ACKNOWLEDGMENTS.md

.github/ACKNOWLEDGMENTS.md

nquesada · 2021-08-11T15:15:43Z

thewalrus/_permanent.py

-def perm(A, quad=True, fsum=False):
-    """Returns the permanent of a matrix via the
-    `Ryser formula <https://en.wikipedia.org/wiki/Computing_the_permanent#Ryser_formula>`_.
+def perm(A, quad=True, fsum=False, method="ryser"):


Suggested change

def perm(A, quad=True, fsum=False, method="ryser"):

def perm(A, quad=True, fsum=False, method="bbfg"):

…er and BBFG methods

co9olguy · 2021-08-12T16:42:35Z

Thanks @maliasadi!

nquesada · 2021-08-12T16:45:01Z

indeed, really nice addition @maliasadi , aka commander of threads :)

maliasadi · 2021-08-12T17:04:04Z

Thanks @maliasadi!

Couldn't done it without @mlxd and @nquesada suggestions!

ali and others added 6 commits July 24, 2021 01:41

Add C++ and Python support for calc. the matrix permanent using the B…

7c4b884

…BFG algorithm and Gray code ordering (XanaduAI#263)

Update BBFG (serial) algorithm support (XanaduAI#263)

49abe62

Update comments (XanaduAI#263)

e228c45

Merge branch 'XanaduAI:master' into master

2712219

Optimize BBFG algorithm support w/ adding *BBFG_serial2

7f10428

Update CHANGELOG.md

d339386

Update BBFG algorithm Python test-cases

decffe0

nquesada reviewed Jul 29, 2021

View reviewed changes

thewalrus/_permanent.py Outdated Show resolved Hide resolved

nquesada reviewed Jul 29, 2021

View reviewed changes

thewalrus/tests/test_permanent.py Outdated Show resolved Hide resolved

nquesada and others added 5 commits July 29, 2021 16:46

Apply suggestions from code review

020da95

Add an optional argument: method to perm supporting Ryser and BBFG algo

e37f077

Merge branch 'master' into master

a3e5f37

Apply suggestions from code factor

b31a1b7

Apply suggestions from code factor

9c980c3

mlxd suggested changes Jul 30, 2021

View reviewed changes

ali added 3 commits August 1, 2021 00:32

Apply suggestions from code review

1767567

Apply suggestions from code factor

b26ef7b

Apply suggestions from code factor

807fe2f

Update the BBFG algorithm

c9c287a

maliasadi requested a review from mlxd August 3, 2021 16:40

Apply suggestions from code review

9c8e0a7

mlxd approved these changes Aug 10, 2021

View reviewed changes

Update CHANGELOG.md (XanaduAI#267)

d94277f

Update ACKNOWLEDGMENTS.md (XanaduAI#267)

f92d36b

nquesada reviewed Aug 10, 2021

View reviewed changes

.github/ACKNOWLEDGMENTS.md Outdated Show resolved Hide resolved

Update ACKNOWLEDGMENTS.md

13e7042

nquesada approved these changes Aug 10, 2021

View reviewed changes

nquesada reviewed Aug 11, 2021

View reviewed changes

nquesada and others added 3 commits August 11, 2021 11:15

Apply suggestions from code review

a46e35a

Update permanent Python tests to tackle the accuracy diff between Rys…

0a8708e

…er and BBFG methods

Merge branch 'master' into master

c03fabf

nquesada merged commit b1de9b9 into XanaduAI:master Aug 12, 2021

nquesada mentioned this pull request Aug 12, 2021

Add support for calculating the permanent using the BBFG algorithm #263

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add support for calculating the permanent using the BBFG algorithm #267

Add support for calculating the permanent using the BBFG algorithm #267

maliasadi commented Jul 28, 2021

maliasadi commented Jul 28, 2021

mlxd left a comment

maliasadi commented Aug 1, 2021

jakeffbulmer commented Aug 5, 2021

maliasadi commented Aug 6, 2021 •

edited

Loading

codecov bot commented Aug 8, 2021 •

edited

Loading

jakeffbulmer commented Aug 9, 2021

mlxd left a comment

maliasadi commented Aug 10, 2021

nquesada commented Aug 10, 2021

nquesada Aug 11, 2021

co9olguy commented Aug 12, 2021

nquesada commented Aug 12, 2021 •

edited

Loading

maliasadi commented Aug 12, 2021

	def perm(A, quad=True, fsum=False, method="ryser"):
	def perm(A, quad=True, fsum=False, method="bbfg"):

Add support for calculating the permanent using the BBFG algorithm #267

Add support for calculating the permanent using the BBFG algorithm #267

Conversation

maliasadi commented Jul 28, 2021

maliasadi commented Jul 28, 2021

mlxd left a comment

Choose a reason for hiding this comment

maliasadi commented Aug 1, 2021

jakeffbulmer commented Aug 5, 2021

maliasadi commented Aug 6, 2021 • edited Loading

codecov bot commented Aug 8, 2021 • edited Loading

Codecov Report

jakeffbulmer commented Aug 9, 2021

mlxd left a comment

Choose a reason for hiding this comment

maliasadi commented Aug 10, 2021

nquesada commented Aug 10, 2021

nquesada Aug 11, 2021

Choose a reason for hiding this comment

co9olguy commented Aug 12, 2021

nquesada commented Aug 12, 2021 • edited Loading

maliasadi commented Aug 12, 2021

maliasadi commented Aug 6, 2021 •

edited

Loading

codecov bot commented Aug 8, 2021 •

edited

Loading

nquesada commented Aug 12, 2021 •

edited

Loading