towneszhou / pysigma Goto Github PK

Unit Test for _nodes.py

• FactorNode.add_link()

• VariableNode.add_link()

• DFN.add_link() and DFN.compute()

• DVN.add_link() andDVN.compute()

• LTMFN.add_link(), LTMFN.toggle_draw() + LTMFN.draw_particles(), and LTMFN.compute()

• WMVN.compute()

• PBFN.add_link() and PBFN.set_perception() + PBFN.compute()

• WMFN.add_link(), WMFN.update_memory() + WMFN.compute()

• AlphaFactorNode.add_link()

• RelMapNode.inward_compute() and RelMapNode.outward_compute()

• ExpSumNode.inward_compute() and ExpSumNode.outward_compute()

msg_shape is defined as a tuple of torch.Size and has assertion check in line 84.

This is called wrongly in toggle_draw

def test_parameter_batch_permute(self):
    m1 = Message(MessageType.Parameter,
                 batch_shape=torch.Size([2, 3, 4]),
                 param_shape=torch.Size([2]),
                 parameters=torch.ones(2, 3, 4, 2)
                 )
    m2 = m1.batch_permute([2, 0, 1])

In this case, pos_target_dims == [2, 0, 1]
b_p_dims = pos_target_dims + [0] == [2, 0, 1, 0]

new_parameters = self.parameters.permute(b_p_dims) gives runtime error:
repeated dim in permute

For the batch_flatten method for particles, in line 910

RuntimeError: number of dims don't match in permute

This shows up either when dim is None or dim is a normal list of int

test code:

m1 = Message(MessageType.Particles,
             sample_shape=torch.Size([2]),
             batch_shape=torch.Size([3, 2, 3]),
             event_shape=torch.Size([2]),
             particles=torch.ones(2, 2),
             weights=self.helper_normalize(torch.rand(2, 3, 2, 3)),
             log_density=torch.ones(2)
             )

m2 = m1.batch_flatten(None)
assert m2.size() == torch.Size([2, 18, 2])

m3 = m1.batch_flatten([0])
assert m3.size() == torch.Size([2, 2, 3, 3, 2])

m4 = m1.batch_flatten([1, 2])
assert m4.size() == torch.Size([2, 3, 6, 2])

maybe use torch.all() and torch.eq() to compare tensors

In line 1007, the parameter new_batch_shape is passed in to create a new message.
However, in situations where -1 exist in new_batch_shape to indicate unchanged of dimensions, the passed in shape with a negative value will be rejected at the assertion when creating new messages.

>           assert self.b_shape + self.p_shape == self.parameters.shape
E           AssertionError

Unit Test for Message class in ./defs.py

• __init__()

• __add__()

• __mul__()

• clone()

• batch_permute()

• batch_unsqueeze()

• batch_index_select()

• batch_index_put()

• batch_diagonal()

• batch_diag_embed()

• batch_narrow()

• batch_broaden()

• batch_summarize()

• batch_flatten()

• batch_reshape()

• batch_expand()

With, default dims=None, the assertion isinstance(dims, Iterable) will be triggered

all(self.s_shape[j] + self.e_shape[j] == p.shape for j, p in enumerate(self.particles))

self.shape is a torch.Size object, indexing on it gives integer, p.shape is torch.Size
the addition of 2 integers could not compare to torch.Size

:param msg_shape    Fixed message shape that this linkdata will carry. Used for checking dimensions
For Parameter message, should be (batch_shape + param_shape)
For particles message, should be (sample_shape + batch_shape + event_shape)

A None shape causes assertion error in line 286

This test code is expected to have an effect:

def test_batch_broaden_parameter(self):
    para = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32)
    m1 = Message(MessageType.Parameter,
                 batch_shape=torch.Size([3, 3]),
                 param_shape=torch.Size([1]),
                 parameters=para.unsqueeze(-1)
                 )
    m2 = m1.batch_broaden(0, 5)

[1, 2, 3]                        [1, 2, 3]
[4, 5, 6]           ===>         [4, 5, 6]  
[7, 8, 9]                        [7, 8, 9]
                                 [0, 0, 0]
                                 [0, 0, 0]

However, new_parameter has shape [3, 3, 1]
while to_concat has shape [2, 3]
They cannot be concatenated together

Hello. The wiki link is broken. Can you please provide an updated link to the documentation?

Thank you very much!

In the out message initialization in PBFN,

particles=self.buffer
self.buffer = obs
but obs has shape ([num_obs] + b_shape + e_shape)

Could add default parameter input to batch operation function, such as
batch_diagonal(dim1=0, dim2=1)

Some assertion error does not provide explanation messages. They could be added to better inform the user.

do you mean:

# Dimensions of event tensor: [N, B_1, ..., B_n, (S_1+...+S_m)]
self.event_dims = Size([self.index_arg.size] +
[v.size for v in self.relational_args] +
[sum([v.size for v in self.random_args])])

In function batch_flatten(self, dims=None), if dims does not contains 0, then in line 858, other_dims would contain 0

Then in line 864: prod(other_dims) would be 0, since one of the elements is 0, the resulting size would be torch.Size([a, b, c, 0])

And this Size([0]) causes dimension mismatch when initiating the new message.

For instance: [3, 3, 0] + [2] != [3, 3, 2]

There is an assertion in FactorNode add_link:
assert linkdata.fn is self
but not a counterpart in VariableNode add_link