Adding probabilities, weighted edges and annotations

[KaminiAggarwal]

Hi,

I'm looking for details on below points for working on a use case involving probabilities.

• Does pyreason support creation of probabilistic rules or facts? If yes, please provide an example.
• Also, is it possible to specify weights for each rule or edge?
• It is unclear from documentation on the usage of annotation functions. Can you please provide an example on how to create and use an annotation function within a rule?

[KaminiAggarwal]

Hi @dyumanaditya,

Please help me with the details for above mentioned points.

[dyumanaditya]

Hello @KaminiAggarwal,

1. Could you clarify what you mean when you say you want to use "probabilistic rules"?
2. This is not supported but if you need it for what you're doing I can add that feature soon.
3. Here's a short snippet on how you can use annotation functions that will be added to the documentation soon:

Here are instructions on how to use annotation functions with PyReason.

What are annotation functions?

User defined Python functions that are called when all clauses in a rule have been satisfied to annotate the target of the rule. Annotation functions have access to the bounds of grounded atoms for each clause in the rule and use these bounds to make an annotation for the target of the rule.

The Structure of an annotation function

Only specifically structured annotation functions are allowed. The function has to be decorated with @numba.njit it has to take in 2 parameters whether you use them or not and it has to return 2 numbers
Example:

import numba
import numpy as np

@numba.njit
def ann_fn(annotations, weights):
    #  annotations contains the bounds of the atoms that were used to ground the rule. It is a nested list that contains a list for each clause
    # You can access for example the first grounded atom's bound by doing: annotations[0][0].lower or annotations[0][0].upper 
    a, b = np.random.rand(2)
    return a, b

Adding the function in PyReason (using function example above)

Use pr.add_annotation_function(ann_fn) to add the function ann_fn to PyReason. Then you can create rules of the following format:

pred1(x) : ann_fn <- pred2(x,y) : [1,1], pred3(y) : [1,1]

This will set the bounds of pred1(x) to be whatever ann_fn returned [a,b]

[KaminiAggarwal]

Thank you @dyumanaditya for providing the details. They are very useful.

Also, regarding probability, Here's a simple use case below:

trendy(x) <- cool_car(x) or cool_pet(x)

What is the probability of a person being trendy? Given the probability of x owning a cool_pet is 0.05 and x owning a cool_car is 0.02.

Thereafter, if we further specify a rule that if all people in a group are trendy, the group is popular.

popular(x) -> GroupMember(x,y) and trendy(y)

What is the probability of a group being popular?

[KaminiAggarwal]

@dyumanaditya Here is another example of how we want to use edge probabilities:

Consider an unstable network with nodes A, B & C.
At timestep 1, A is connected to B with P=0.8. B -> C p=0.7
What is P: A->C at t=2?

[kmukherji]

Hi @KaminiAggarwal in my opinion, probability is not the best way to go about it. While I understand where you are coming from, pyreason is built on reasoning about graphs and connections in graphs must either exist or not exist. However, what we do already support is open-world interval logic. So, every ground atom has an annotation in the range [0.0, 1.0]. This is not probability, but instead uncertainty.
So for example, tall(X): [lower, upper] bounds the uncertainty of X belonging to the 'tall' class.

While on the surface, and in most simple cases - you may choose to model probability as uncertainty; it is worth exploring if in your domain this simplification holds.