Learning in LTN¶

This tutorial explains how to learn some language symbols (predicates, functions, constants) using the satisfaction of a knowledgebase as an objective. It expects basic familiarity of the first two turoials on LTN (grounding symbols and connectives).

We use the following simple example to illustrate learning in LTN.

The domain is the square $[0,4] \times [0,4]$. We have one example of the class $A$ and one example of the class $B$. The rest of the individuals are not labelled, but there are two assumptions:

• $A$ and $B$ are mutually exclusive,
• any two close points should share the same label.

We define the membership predicate $C(x,l)$, where $x$ is an individual and $l$ is a onehot label to denote the two classes. $C$ is approximated by a simple MLP. The last layer, that computes probabilities per class, uses a softmax activation, ensuring that the classes are mutually-exclusive.

We define the knowledgebase $\mathcal{K}$ composed of the following rules:

The objective is to learn the predicate $C$ to maximize the satisfaction of $\mathcal{K}$. If $\theta$ denotes the set of trainable parameters, the task is :

To evaluate the grounding of each formula, one has to define the grounding of the non-logical symbols and of the operators.

Notice the operator for equivalence $p \leftrightarrow q$; in LTN, it is simply implemented as $(p \rightarrow q)\land(p \leftarrow q)$ using one operator for conjunction and one operator for implication.

If there are several closed formulas in $\mathcal{K}$, their truth values need to be aggregated. We recommend to use the generalized mean inspired operator pMeanError, already used to implement $\forall$. The hyperparameter again allows flexibility in how strict the formula aggregation is ($p = 1$ corresponds to mean; $p \to +\inf$ corresponds to min).

The knowledgebase should be written inside of a function that is decorated with tf.function. This Tensorflow decorator compiles the function into a callable TensorFlow graph (static).

It is important to always run (forward pass) the knowledgebase once before training, as Tensorflow initializes weights and compiles the graph during the first call.

Eventually, one can write a custom training loop in Tensorflow.

After a few epochs, the system has learned to identify samples close to the point $a$ (resp. $b$) as belonging to class $A$ (resp. $B$) based on the rules of the knowledgebase.

Special Cases¶

Variables grounded by batch¶

When working with batches of data, grounding the variables with different values at each step:

1. Pass the values in arguments to the knowledgebase function,
2. Create the ltn variables within the function.

@tf.function
def axioms(data_x, data_y):
    x = ltn.Variable("x", data_x)
    y = ltn.Variable("y", data_y)
    return Forall([x,y],P([x,y]))

...
for epoch in range(epochs):
    for batch_x, batch_y in dataset:
        with tf.GradientTape() as tape:
            loss_value = 1. - axioms(batch_x, batch_y)
        grads = tape.gradient(loss_value, trainable_variables)
        optimizer.apply_gradients(zip(grads, trainable_variables))

Variables denoting a sequence of trainable constants¶

When a variable denotes a sequence of trainable constants (embeddings):

1. Do not create the variable outside the scope of tf.GradientTape(),
2. Create the variable within the training step function.

c1 = ltn.Constant([2.1,3], trainable=True)
c2 = ltn.Constant([4.5,0.8], trainable=True)
# Do not assign the variable here. Tensorflow would not keep track of the 
# gradients between c1/c2 and x during training.
...
@tf.function
def axioms():
    # The assignation must be done within the tf.GradientTape, 
    # inside of the training step function.
    x = ltn.Variable.from_constants("x", [c1,c2])
    return Forall(x,P(x))
...
for epoch in range(epochs):
    with tf.GradientTape() as tape:
        loss_value = 1. - axioms() # the training step function is called within the tape.
    grads = tape.gradient(loss_value, trainable_variables)
    optimizer.apply_gradients(zip(grads, trainable_variables))