LTNtorch

https://logictensornetworks.github.io/LTNtorch/
Admin
LTNtorch is a PyTorch implementation of Logic Tensor Networks, a Neural-Symbolic approach for...
Tokens:23,809
Snippets:255
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Equiv Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Illustrates the setup for the Equiv fuzzy operator, specifying conjunction and implication operators.

```python
>>> import ltn
>>> import torch
```

--------------------------------

### Trainable constant

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Example of creating and inspecting a trainable LTN constant (embedding).

```python
>>> t_c = ltn.Constant(torch.tensor([[3.4, 2.3, 5.6],
...                                  [6.7, 5.6, 4.3]]), trainable=True)
>>> print(t_c)
Constant(value=tensor([[3.4000, 2.3000, 5.6000],
        [6.7000, 5.6000, 4.3000]], requires_grad=True), free_vars=[])
>>> print(t_c.value)
tensor([[3.4000, 2.3000, 5.6000],
        [6.7000, 5.6000, 4.3000]], requires_grad=True)
>>> print(t_c.free_vars)
[]
>>> print(t_c.shape())
torch.Size([2, 3])
```

--------------------------------

### Guarded Quantification Example

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Demonstrates guarded quantification with `Forall` where a condition is applied to filter variables before aggregation.

```python
>>> out = Forall([x, y], p(x, y),
...             cond_vars=[x],
...             cond_fn=lambda x: torch.less(torch.sum(x.value, dim=1), 1.))
>>> print(out)
LTNObject(value=tensor(0.9844, dtype=torch.float64), free_vars=[])
>>> print(out.value)
tensor(0.9844, dtype=torch.float64)
>>> print(out.free_vars)
[]
>>> print(out.shape())
torch.Size([])
```

--------------------------------

### Diagonal Quantification Example

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Compares universal quantification with and without diagonal quantification using `ltn.diag()`.

```python
>>> x = ltn.Variable('x', torch.tensor([[0.3, 1.3],
...                                     [0.3, 0.3]]))
>>> y = ltn.Variable('y', torch.tensor([[2.3, 0.3],
...                                    [1.2, 3.4]]))
>>> out = Forall(ltn.diag(x, y), p(x, y)) # with diagonal quantification
>>> out_without_diag = Forall([x, y], p(x, y)) # without diagonal quantification
>>> print(out_without_diag)
LTNObject(value=tensor(0.9788), free_vars=[])
>>> print(out_without_diag.value)
tensor(0.9788)
>>> print(out)
LTNObject(value=tensor(0.9888), free_vars=[])
>>> print(out.value)
tensor(0.9888)
>>> print(out.free_vars)
[]
>>> print(out.shape())
torch.Size([])
```

--------------------------------

### Non-trainable constant

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Example of creating and inspecting a non-trainable LTN constant.

```python
>>> import ltn
>>> import torch
>>> c = ltn.Constant(torch.tensor([3.4, 5.4, 4.3]))
>>> print(c)
Constant(value=tensor([3.4000, 5.4000, 4.3000]), free_vars=[])
>>> print(c.value)
tensor([3.4000, 5.4000, 4.3000])
>>> print(c.free_vars)
[]
>>> print(c.shape())
torch.Size([3])
```

--------------------------------

### OrLuk Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the initialization of the OrLuk (Lukasiewicz fuzzy disjunction) operator.

```python
>>> import ltn
>>> import torch
>>> Or = ltn.Connective(ltn.fuzzy_ops.OrLuk())
>>> print(Or)
Connective(connective_op=OrLuk())
```

--------------------------------

### OrMax Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the OrMax (Godel fuzzy disjunction) operator with LTN variables and predicates, showcasing broadcasting behavior.

```python
>>> import ltn
>>> import torch
>>> Or = ltn.Connective(ltn.fuzzy_ops.OrMax())
>>> print(Or)
Connective(connective_op=OrMax())
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                      torch.sum(x, dim=1)
...                                   ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Or(p(x), p(y)).value)
tensor([[0.6682, 0.6365, 0.6365],
        [0.7109, 0.7109, 0.7109]])
```

--------------------------------

### AggregPMeanError Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the AggregPMeanError operator for universal quantification.

```python
>>> import ltn
>>> import torch
>>> Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregPMeanError(), quantifier='f')
>>> print(Forall)
Quantifier(agg_op=AggregPMeanError(p=2, stable=True), quantifier='f')
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9], [0.7]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109, 0.6682])
>>> print(Forall(x, p(x)).value)
tensor(0.6704)
```

--------------------------------

### Universal quantification on both variables of the same predicate.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example illustrates universal quantification on both variables of a predicate, detailing the output shape and free variables when all variables are quantified.

```python
>>> out = Forall([x, y], p(x, y))
>>> print(out)
LTNObject(value=tensor(0.9882), free_vars=[])
>>> print(out.value)
tensor(0.9882)
>>> print(out.free_vars)
[]
>>> print(out.shape())
torch.Size([])
```

--------------------------------

### AggregPMean Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the AggregPMean operator for existential quantification.

```python
>>> import ltn
>>> import torch
>>> Exists = ltn.Quantifier(ltn.fuzzy_ops.AggregPMean(), quantifier='e')
>>> print(Exists)
Quantifier(agg_op=AggregPMean(p=2, stable=True), quantifier='e')
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9], [0.7]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109, 0.6682])
>>> print(Exists(x, p(x)).value)
tensor(0.6726)
```

--------------------------------

### SatAgg aggregation with torch.Tensor input

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

This example demonstrates that SatAgg can accept torch.Tensor inputs that represent the result of closed formulas. It shows that if a torch.Tensor contains a scalar in [0., 1.], it can be aggregated with ltn.core.LTNObject instances. The example aggregates a closed formula f1 and a scalar tensor f2 using the pMeanError aggregation operator.

```python
x = ltn.Variable('x', torch.tensor([[0.1, 0.03],
                                     [2.3, 4.3]]))
p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
                                     torch.sum(x, dim=1)
                                  ))
Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregPMeanError(), quantifier='f')
f1 = Forall(x, p(x))
f2 = torch.tensor(0.7)
sat_agg = ltn.fuzzy_ops.SatAgg(ltn.fuzzy_ops.AggregPMeanError())
print(sat_agg)
out = sat_agg(f1, f2)
print(type(out))
print(out)
```

--------------------------------

### SatAgg aggregation of closed formulas

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

This example demonstrates how SatAgg can be used to aggregate the truth values of formulas contained in a knowledge base. It shows that SatAgg takes a tuple of ltn.core.LTNObject and/or torch.Tensor as input. When torch.Tensor are given, they must be scalars in [0., 1.]. The example illustrates the aggregation of closed formulas f1, f2, and f3 using the pMeanError aggregation operator, resulting in a satisfaction level of the entire knowledge base as a torch.Tensor.

```python
import ltn
import torch
x = ltn.Variable('x', torch.tensor([[0.1, 0.03],
                                     [2.3, 4.3]]))
y = ltn.Variable('y', torch.tensor([[3.4, 2.3],
                                     [5.4, 0.43]]))
p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
                                     torch.sum(x, dim=1)
                                  ))
q = ltn.Predicate(func=lambda x, y: torch.nn.Sigmoid()(
                                         torch.sum(torch.cat([x, y], dim=1),
                                     dim=1)))
Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregPMeanError(), quantifier='f')
And = ltn.Connective(ltn.fuzzy_ops.AndProd())
f1 = Forall(x, p(x))
f2 = Forall([x, y], q(x, y))
f3 = And(Forall([x, y], q(x, y)), Forall(x, p(x)))
sat_agg = ltn.fuzzy_ops.SatAgg(ltn.fuzzy_ops.AggregPMeanError())
print(sat_agg)
out = sat_agg(f1, f2, f3)
print(type(out))
print(out)
```

--------------------------------

### Equiv Operator Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the Equiv connective operator with AndProd and ImpliesReichenbach, and applies it to predicates.

```python
>>> Equiv = ltn.Connective(ltn.fuzzy_ops.Equiv(
...                             and_op=ltn.fuzzy_ops.AndProd(),
...                             implies_op=ltn.fuzzy_ops.ImpliesReichenbach()
...                         ))
>>> print(Equiv)
Connective(connective_op=Equiv(and_op=AndProd(stable=True), implies_op=ImpliesReichenbach(stable=True)))
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Equiv(p(x), p(y)).value)
tensor([[0.5972, 0.5708, 0.5645],
        [0.6165, 0.5718, 0.5617]])
```

--------------------------------

### OrProbSum Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the OrProbSum (Goguen fuzzy disjunction) operator with LTN variables and predicates, including the stable version and broadcasting.

```python
>>> import ltn
>>> import torch
>>> Or = ltn.Connective(ltn.fuzzy_ops.OrProbSum())
>>> print(Or)
Connective(connective_op=OrProbSum(stable=True))
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                      torch.sum(x, dim=1)
...                                   ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Or(p(x), p(y)).value)
tensor([[0.8793, 0.8363, 0.8273],
        [0.9040, 0.8698, 0.8626]])
```

--------------------------------

### Unary predicate defined using a `torch.nn.Sequential`.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example shows how to define a unary predicate using a `torch.nn.Sequential` model.

```python
>>> import ltn
>>> import torch
>>> predicate_model = torch.nn.Sequential(
...                         torch.nn.Linear(4, 2),
...                         torch.nn.ELU(),
...                         torch.nn.Linear(2, 1),
...                         torch.nn.Sigmoid()
...                   )
>>> p = ltn.Predicate(model=predicate_model)
>>> print(p)
Predicate(model=Sequential(
  (0): Linear(in_features=4, out_features=2, bias=True)
  (1): ELU(alpha=1.0)
  (2): Linear(in_features=2, out_features=1, bias=True)
  (3): Sigmoid()
))

```

--------------------------------

### Behavior of a binary predicate evaluated on two variables.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example demonstrates the behavior of a binary predicate evaluated on two variables, showing the output shape, free variables, value, and shape of the resulting LTNObject.

```python
>>> import ltn
>>> import torch
>>> p = ltn.Predicate(func=lambda a, b: torch.nn.Sigmoid()(
...                                         torch.sum(torch.cat([a, b], dim=1),
...                                     dim=1)))
>>> x = ltn.Variable('x', torch.tensor([[0.3, 1.3],
...                                     [0.3, 0.3]]))
>>> y = ltn.Variable('y', torch.tensor([[2.3, 0.3, 0.4],
...                                     [1.2, 3.4, 1.3],
...                                     [2.3, 1.4, 1.4]]))
>>> out = p(x, y)
>>> print(out)
LTNObject(value=tensor([[0.9900, 0.9994, 0.9988],
        [0.9734, 0.9985, 0.9967]]), free_vars=['x', 'y'])
>>> print(out.value)
tensor([[0.9900, 0.9994, 0.9988],
        [0.9734, 0.9985, 0.9967]])
>>> print(out.free_vars)
['x', 'y']
>>> print(out.shape())
torch.Size([2, 3])
```

--------------------------------

### Universal quantification on one single variable of the same predicate.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example shows universal quantification on a single variable of a predicate, explaining the fuzzy semantics, the output LTNObject, its shape, and free variables.

```python
>>> Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregPMeanError(), quantifier='f')
>>> print(Forall)
Quantifier(agg_op=AggregPMeanError(p=2, stable=True), quantifier='f')
>>> out = Forall(x, p(x, y))
>>> print(out)
LTNObject(value=tensor([0.9798, 0.9988, 0.9974]), free_vars=['y'])
>>> print(out.value)
tensor([0.9798, 0.9988, 0.9974])
>>> print(out.free_vars)
['y']
>>> print(out.shape())
torch.Size([3])
```

--------------------------------

### ImpliesGoguen Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the Goguen fuzzy implication operator with LTN variables and predicates, highlighting the stable version.

```python
>>> import ltn
>>> import torch
>>> Implies = ltn.Connective(ltn.fuzzy_ops.ImpliesGoguen())
>>> print(Implies)
Connective(connective_op=ImpliesGoguen(stable=True))
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                      torch.sum(x, dim=1)
...                                   ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Implies(p(x), p(y)).value)
tensor([[1.0000, 0.8639, 0.8248],
        [0.9398, 0.7733, 0.6622]])
```

--------------------------------

### Or (Lukasiewicz Fuzzy Disjunction)

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the use of the Lukasiewicz fuzzy disjunction operator with predicates and variables.

```python
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Or(p(x), p(y)).value)
tensor([[1., 1., 1.],
        [1., 1., 1.]])
```

--------------------------------

### AggregMean Operator Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Illustrates the use of the AggregMean operator for fuzzy aggregation, also demonstrated with a universal quantifier (Forall).

```python
>>> import ltn
>>> import torch
>>> Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregMean(), quantifier='f')
>>> print(Forall)
Quantifier(agg_op=AggregMean(), quantifier='f')
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9], [0.7]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109, 0.6682])
>>> print(Forall(x, p(x)).value)
tensor(0.6719)
```

--------------------------------

### AggregMin Operator Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Shows how to use the AggregMin operator for fuzzy aggregation, specifically with a universal quantifier (Forall).

```python
>>> import ltn
>>> import torch
>>> Forall = ltn.Quantifier(ltn.fuzzy_ops.AggregMin(), quantifier='f')
>>> print(Forall)
Quantifier(agg_op=AggregMin(), quantifier='f')
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9], [0.7]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109, 0.6682])
>>> print(Forall(x, p(x)).value)
tensor(0.6365)
```

--------------------------------

### Universal quantification on one variable, and existential quantification on the other variable, of the same predicate.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example demonstrates nested quantification, applying universal quantification to one variable and existential quantification to another using a nested syntax.

```python
>>> Exists = ltn.Quantifier(ltn.fuzzy_ops.AggregPMean(), quantifier='e')
>>> print(Exists)
Quantifier(agg_op=AggregPMean(p=2, stable=True), quantifier='e')
>>> out = Forall(x, Exists(y, p(x, y)))
>>> print(out)
LTNObject(value=tensor(0.9920), free_vars=[])
>>> print(out.value)
tensor(0.9920)
>>> print(out.free_vars)
[]
>>> print(out.shape())
torch.Size([])
```

--------------------------------

### LTN Function defined using a torch.nn.Sequential model

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example shows how to define an LTN function using a PyTorch Sequential model.

```python
>>> import ltn
>>> import torch
>>> function_model = torch.nn.Sequential(
...                         torch.nn.Linear(4, 3),
...                         torch.nn.ELU(),
...                         torch.nn.Linear(3, 2)
...                   )
>>> f = ltn.Function(model=function_model)
>>> print(f)
Function(model=Sequential(
  (0): Linear(in_features=4, out_features=3, bias=True)
  (1): ELU(alpha=1.0)
  (2): Linear(in_features=3, out_features=2, bias=True)
))
```

--------------------------------

### Diagonal Quantification Example

Source: https://logictensornetworks.github.io/LTNtorch/quantification.html

Illustrates the concept of diagonal quantification where a predicate is computed only on corresponding elements of input variables, disabling standard LTN broadcasting.

```python
forall_diag = ltn.core.diag(forall)
quantified_formula = forall_diag(P, x, y)
```

--------------------------------

### Goguen fuzzy conjunction operator (product operator)

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the usage of the Goguen fuzzy conjunction operator (product operator) with LTN variables and predicates. It highlights the broadcasting mechanism and the resulting tensor shape.

```python
import ltn
import torch
And = ltn.Connective(ltn.fuzzy_ops.AndProd())
print(And)
p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
                                     torch.sum(x, dim=1)
                                  ))
x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
print(p(x).value)
print(p(y).value)
print(And(p(x), p(y)).value)
```

--------------------------------

### Godel fuzzy conjunction operator (min operator)

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the usage of the Godel fuzzy conjunction operator (min operator) with LTN variables and predicates. It shows how broadcasting works and the resulting tensor shape.

```python
import ltn
import torch
And = ltn.Connective(ltn.fuzzy_ops.AndMin())
print(And)
p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
                                     torch.sum(x, dim=1)
                                  ))
x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
print(p(x).value)
print(p(y).value)
print(And(p(x), p(y)).value)
```

--------------------------------

### Binary function defined using a function (lambda)

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Shows how to define a binary function using a Python lambda function, also utilizing `torch.cat`.

```python
b_f_f = ltn.Function(func=lambda x, y:
                                 torch.repeat_interleave(
                                     torch.sum(torch.cat([x, y], dim=1), dim=1, keepdim=True), 2,
                                     dim=1))
print(b_f_f)
```

--------------------------------

### Binary function defined using a torch.nn.Module

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Demonstrates defining a binary function using a PyTorch Module, including a call to `torch.cat` to merge inputs.

```python
class FunctionModel(torch.nn.Module):
    def __init__(self):
        super(FunctionModel, self).__init__()
        elu = torch.nn.ELU()
        self.dense1 = torch.nn.Linear(4, 5)
        dense2 = torch.nn.Linear(5, 2)

    def forward(self, x, y):
        x = torch.cat([x, y], dim=1)
        x = self.elu(self.dense1(x))
        out = self.dense2(x)
        return out

function_model = FunctionModel()
b_f = ltn.Function(model=function_model)
print(b_f)
```

--------------------------------

### ImpliesReichenbach Example

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Demonstrates the usage of the Reichenbach fuzzy implication operator with LTN variables and predicates.

```python
>>> import ltn
>>> import torch
>>> Implies = ltn.Connective(ltn.fuzzy_ops.ImpliesReichenbach())
>>> print(Implies)
Connective(connective_op=ImpliesReichenbach(stable=True))
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                      torch.sum(x, dim=1)
...                                   ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Implies(p(x), p(y)).value)
tensor([[0.7888, 0.7134, 0.6976],
        [0.7640, 0.6799, 0.6622]])
```

--------------------------------

### Evaluation of a binary function on two variables

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Illustrates evaluating a binary function with two variable inputs, explaining the resulting `LTNObject`'s value, free variables, and shape.

```python
x = ltn.Variable('x', torch.tensor([[0.4, 0.3],
                                     [0.32, 0.043]]))
y = ltn.Variable('y', torch.tensor([[0.4, 0.04, 0.23],
                                     [0.2, 0.04, 0.32],
                                     [0.06, 0.08, 0.3]]))
out = b_f_f(x, y)
print(out)
print(out.value)
```

--------------------------------

### Behavior of predicate with diagonal quantification.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Demonstrates the behavior of a predicate with diagonal quantification, highlighting differences in broadcasting, output shape, and free variables compared to standard quantification.

```python
>>> import ltn
>>> import torch
>>> p = ltn.Predicate(func=lambda a, b: torch.nn.Sigmoid()(
...                                         torch.sum(torch.cat([a, b], dim=1), dim=1)
...                                     ))
>>> x = ltn.Variable('x', torch.tensor([[0.3, 0.56, 0.43], [0.3, 0.5, 0.04]]))
>>> y = ltn.Variable('y', torch.tensor([[0.4, 0.004], [0.3, 0.32]]))
>>> x, y = ltn.diag(x, y)
>>> out = p(x, y)
>>> print(out.value)
tensor([0.8447, 0.8115])
>>> print(out.free_vars)
['diag_x_y']
>>> print(out.shape())
torch.Size([2])

```

--------------------------------

### Evaluation of a unary function on a constant

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Illustrates evaluating a unary function with a constant input, showing the resulting `LTNObject` properties.

```python
c = ltn.Constant(torch.tensor([0.5, 0.01, 0.34, 0.001]))
out = f_f(c)
print(type(out))
print(out)
print(out.value)
print(out.free_vars)
print(out.shape())
```

--------------------------------

### LTN Function defined using a Python function

Source: https://logictensornetworks.github.io/LTNtorch/core.html

This example demonstrates defining an LTN function using a Python lambda function.

```python
>>> f_f = ltn.Function(func=lambda x: torch.repeat_interleave(
...                                              torch.sum(x, dim=1, keepdim=True), 2, dim=1)
...                                         )
>>> print(f_f)
Function(model=LambdaModel())
```

--------------------------------

### ImpliesGodel (Godel Fuzzy Implication)

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the use of the Godel fuzzy implication operator with predicates and variables, showcasing LTN broadcasting.

```python
>>> import ltn
>>> import torch
>>> Implies = ltn.Connective(ltn.fuzzy_ops.ImpliesGodel())
>>> print(Implies)
Connective(connective_op=ImpliesGodel())
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Implies(p(x), p(y)).value)
tensor([[1.0000, 0.5498, 0.5250],
        [0.6682, 0.5498, 0.5250]])
```

--------------------------------

### Lukasiewicz fuzzy conjunction operator

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the application of the Lukasiewicz fuzzy conjunction operator. It illustrates the broadcasting behavior and the shape of the resulting tensor.

```python
import ltn
import torch
And = ltn.Connective(ltn.fuzzy_ops.AndLuk())
print(And)
p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
                                     torch.sum(x, dim=1)
                                  ))
x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
print(p(x).value)
print(p(y).value)
print(And(p(x), p(y)).value)
```

--------------------------------

### Evaluation of a unary function on a variable

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Demonstrates evaluating a unary function with a variable input, highlighting the `LTNObject`'s free variables and shape.

```python
v = ltn.Variable('v', torch.tensor([[0.4, 0.3],
                                     [0.32, 0.043]]))
out = f_f(v)
print(out)
print(out.value)
print(out.free_vars)
print(out.shape())
```

--------------------------------

### Use of conjunction (∧) to create a formula.

Source: https://logictensornetworks.github.io/LTNtorch/core.html

Demonstrates the use of a connective operator (conjunction '∧') to create a formula by combining two predicates. It highlights that connective operators can only be applied to inputs representing truth values.

```python
# Example usage would go here, but is not provided in the source text.
# The description indicates that this section is intended to show the use of a connective operator.

```

--------------------------------

### ImpliesKleeneDienes (Kleene Dienes Fuzzy Implication)

Source: https://logictensornetworks.github.io/LTNtorch/fuzzy_ops.html

Example demonstrating the use of the Kleene Dienes fuzzy implication operator with predicates and variables, showcasing LTN broadcasting.

```python
>>> import ltn
>>> import torch
>>> Implies = ltn.Connective(ltn.fuzzy_ops.ImpliesKleeneDienes())
>>> print(Implies)
Connective(connective_op=ImpliesKleeneDienes())
>>> p = ltn.Predicate(func=lambda x: torch.nn.Sigmoid()(
...                                     torch.sum(x, dim=1)
...                                  ))
>>> x = ltn.Variable('x', torch.tensor([[0.56], [0.9]]))
>>> y = ltn.Variable('y', torch.tensor([[0.7], [0.2], [0.1]]))
>>> print(p(x).value)
tensor([0.6365, 0.7109])
>>> print(p(y).value)
tensor([0.6682, 0.5498, 0.5250])
>>> print(Implies(p(x), p(y)).value)
tensor([[0.6682, 0.5498, 0.5250],
        [0.6682, 0.5498, 0.5250]])
```
Tokens:
Raw