Unexpected angle bracket "<" in numpy multiply() of matrices

How does adj.multiply(adj.T > adj) work?

The code runs fine but I don't expect an angle bracket > in a multiply statement. I believe the docs stated to provide two values to multiply(), but it's still working and producing an output matrix by replacing (adj.T > adj) with (True), (False), (adj.T != adj), but not (adj.T = adj). Also, that multiply() method is not attached on the end of a variable, whereas it is used as adj.multiply() here. The source of the method multiply seemed to just convert it to a csr_matrix and run numpy's multiply(), then IIRC converts it back to coo_matrix. The .T of course means "transpose".

# build symmetric adjacency matrix
adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)`

For some context, "adj" is a scipy coo_matrix from graph convolutional network on github, which I'm trying to understand how the input is prepared for.

adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
                    shape=(labels.shape[0], labels.shape[0]),
                    dtype=np.float32)

Attempting to reproduce the code requires running that whole page.

The following is easier to recreate and test:

import numpy as np
import scipy.sparse as sp

asdf = sp.coo_matrix((np.ones(5), (np.ones(5), np.ones(5))), shape=(5,5), 
dtype=np.float32)
print(asdf)
print(asdf.toarray())
asdf = asdf + asdf.T.multiply(asdf.T > asdf) - asdf.multiply(asdf.T > asdf)
print("asdf")
print(asdf.toarray())

at row=1,col=1, value was 5, where a asdf.T.multiply(True) statement doubled its value 5, to 10. Passing two variables separated by space or comma doesn't work.

Update:

I placed a number (not a whole matrix) before the ">" angle bracket and it produced this error:

> /usr/local/lib/python3.6/dist-packages/scipy/sparse/compressed.py:287: SparseEfficiencyWarning: Comparing a sparse matrix with a scalar greater than zero using < is inefficient, try using >= instead.
warn(bad_scalar_msg, SparseEfficiencyWarning)

Seeing that, I realized that there was a different sparse multiply() method that didn't show in google without explicitly typing "sparse". Its documentation is here, but I don't see how it handles an angle bracket or condition.

Make a record for this problem.

When I try to handle confusion about this line of code:

adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)

I need to understand three parts:

1. adj.T > adj

It builds a bool type matrix with the same shape of matrix adj.

2. multiply()

The function achieves Hadamard product actually, rather than Dot product. The official document gives the description: "Point-wise multiplication by another matrix".

3. the way to build symmetric adjacency matrix

We'd better reserve the larger weight item between (i, j) and (j, i) instead of adding them together simply, as the latter will add the weight of the edge.

There is the code to explain them:

import numpy as np
import scipy.sparse as sp  
row = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
col = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2])

A = sp.coo_matrix(([0, 3, 2, 0, 0, 0, 7, 4, 0], (row, col)),
                  shape=(3, 3), dtype=np.float32)
print(A.toarray())
print((A.T > A).toarray())
print(A.T.multiply(A.T > A).toarray())

A = A + A.T.multiply(A.T > A) - A.multiply(A.T > A)
print("The symmetric adjacency matrix:", A.toarray(), sep='\n')

With the following code, I consistently find the multiply() will multiply by a scalar or matrix value, but with a condition, it performs the operator previous to it if the condition is true, without performing a multiplication.

For example, the following:

asdf = asdf + asdf.T.multiply(True)

will only perform the + operation because of the True boolean being passed. In this case there is no multiplication. Same results, if instead of True we have 3>2, which is true, (it doesn't multiply by the 3 or 2).

row = np.array([0,1,2,3,4])
col = np.array([0,1,2,3,4])

asdf = sp.coo_matrix(([1,2,3,4,5], (row, col)), shape=(5,5), dtype=np.float32)
print(asdf)
print(asdf.toarray())
asdf = asdf + asdf.T.multiply(2 < 3) - asdf.multiply(7 != 8)
print("asdf")
print(asdf.toarray())