neuralogic.core package

Subpackages

• neuralogic.core.builder package
  • Submodules
  • neuralogic.core.builder.builder module
    • Builder
      • Builder.build_model()
      • Builder.build_model_from_file()
      • Builder.get_builders()
      • Builder.ground_from_logic_samples()
      • Builder.ground_from_sources()
      • Builder.neuralize()
    • stream_to_list()
  • neuralogic.core.builder.components module
    • Atom
      • Atom.arity
      • Atom.node_type()
      • Atom.predicate
      • Atom.substitutions
    • Grounding
      • Grounding.atoms
      • Grounding.draw()
      • Grounding.get_atoms()
    • NeuralSample
      • NeuralSample.draw()
      • NeuralSample.get_fact()
      • NeuralSample.get_neurons()
      • NeuralSample.neurons
      • NeuralSample.set_fact_value()
      • NeuralSample.target
    • Neuron
      • Neuron.gradient
      • Neuron.substitutions
      • Neuron.value
    • NeuronType
      • NeuronType.Aggregation
      • NeuronType.Atom
      • NeuronType.Fact
      • NeuronType.Negation
      • NeuronType.Rule
      • NeuronType.SplittableAggregation
      • NeuronType.WeightedAtom
      • NeuronType.WeightedRule
  • neuralogic.core.builder.dataset module
    • BuiltDataset
      • BuiltDataset.load_state_dict()
      • BuiltDataset.state_dict()
    • GroundedDataset
      • GroundedDataset.neuralize()
    • IncompatibleKeys
      • IncompatibleKeys.missing_keys
      • IncompatibleKeys.unexpected_keys
  • neuralogic.core.builder.dataset_builder module
    • DatasetBuilder
      • DatasetBuilder.build_dataset()
      • DatasetBuilder.build_examples()
      • DatasetBuilder.build_queries()
      • DatasetBuilder.ground_dataset()
      • DatasetBuilder.merge_queries_with_examples()
    • samples_to_examples_and_queries()
  • Module contents
    • Atom
      • Atom.arity
      • Atom.node_type()
      • Atom.predicate
      • Atom.substitutions
    • Builder
      • Builder.build_model()
      • Builder.build_model_from_file()
      • Builder.get_builders()
      • Builder.ground_from_logic_samples()
      • Builder.ground_from_sources()
      • Builder.neuralize()
    • BuiltDataset
      • BuiltDataset.load_state_dict()
      • BuiltDataset.state_dict()
    • DatasetBuilder
      • DatasetBuilder.build_dataset()
      • DatasetBuilder.build_examples()
      • DatasetBuilder.build_queries()
      • DatasetBuilder.ground_dataset()
      • DatasetBuilder.merge_queries_with_examples()
    • GroundedDataset
      • GroundedDataset.neuralize()
    • Grounding
      • Grounding.atoms
      • Grounding.draw()
      • Grounding.get_atoms()
    • NeuralSample
      • NeuralSample.draw()
      • NeuralSample.get_fact()
      • NeuralSample.get_neurons()
      • NeuralSample.neurons
      • NeuralSample.set_fact_value()
      • NeuralSample.target
    • Neuron
      • Neuron.gradient
      • Neuron.substitutions
      • Neuron.value
    • NeuronType
      • NeuronType.Aggregation
      • NeuronType.Atom
      • NeuronType.Fact
      • NeuronType.Negation
      • NeuronType.Rule
      • NeuronType.SplittableAggregation
      • NeuronType.WeightedAtom
      • NeuronType.WeightedRule
    • StaticGraphDataset
      • StaticGraphDataset.apply_mapping()
      • StaticGraphDataset.fact_mappings
      • StaticGraphDataset.static_sample
      • StaticGraphDataset.targets
    • build_static_graph_dataset()
• neuralogic.core.constructs package
  • Subpackages
    • neuralogic.core.constructs.function package
      • Submodules
      • neuralogic.core.constructs.function.concat module
      • neuralogic.core.constructs.function.enum module
      • neuralogic.core.constructs.function.function module
      • neuralogic.core.constructs.function.function_container module
      • neuralogic.core.constructs.function.function_graph module
      • neuralogic.core.constructs.function.reshape module
      • neuralogic.core.constructs.function.slice module
      • neuralogic.core.constructs.function.softmax module
      • Module contents
  • Submodules
  • neuralogic.core.constructs.factories module
    • AtomFactory
      • AtomFactory.get()
      • AtomFactory.get_predicate()
    • ConstantFactory
      • ConstantFactory.get()
    • HiddenPredicateFactory
      • HiddenPredicateFactory.get()
      • HiddenPredicateFactory.special
    • SpecialPredicateFactory
      • SpecialPredicateFactory.add()
      • SpecialPredicateFactory.add_eval()
      • SpecialPredicateFactory.alldiff()
      • SpecialPredicateFactory.anypred()
      • SpecialPredicateFactory.div_eval()
      • SpecialPredicateFactory.eq()
      • SpecialPredicateFactory.geq()
      • SpecialPredicateFactory.get()
      • SpecialPredicateFactory.gt()
      • SpecialPredicateFactory.hidden
      • SpecialPredicateFactory.leq()
      • SpecialPredicateFactory.lt()
      • SpecialPredicateFactory.max_eval()
      • SpecialPredicateFactory.maxcard()
      • SpecialPredicateFactory.min_eval()
      • SpecialPredicateFactory.mod()
      • SpecialPredicateFactory.mod_eval()
      • SpecialPredicateFactory.mul_eval()
      • SpecialPredicateFactory.neq()
      • SpecialPredicateFactory.next()
      • SpecialPredicateFactory.sub()
      • SpecialPredicateFactory.sub_eval()
      • SpecialPredicateFactory.truepred()
    • VariableFactory
      • VariableFactory.get()
  • neuralogic.core.constructs.java_objects module
    • JavaFactory
      • JavaFactory.add_metadata_function()
      • JavaFactory.add_parametrized_function()
      • JavaFactory.atom_to_clause()
      • JavaFactory.get_conjunction()
      • JavaFactory.get_generic_relation()
      • JavaFactory.get_lifted_example()
      • JavaFactory.get_metadata()
      • JavaFactory.get_new_weight_factory()
      • JavaFactory.get_predicate()
      • JavaFactory.get_predicate_metadata_pair()
      • JavaFactory.get_query()
      • JavaFactory.get_relation()
      • JavaFactory.get_rule()
      • JavaFactory.get_term()
      • JavaFactory.get_valued_fact()
      • JavaFactory.get_variable_factory()
      • JavaFactory.get_weight()
      • JavaFactory.to_clause()
    • ValueFactory
      • ValueFactory.from_java()
      • ValueFactory.get_value()
  • neuralogic.core.constructs.metadata module
    • Metadata
      • Metadata.aggregation
      • Metadata.combination
      • Metadata.combine()
      • Metadata.copy()
      • Metadata.duplicate_grounding
      • Metadata.from_iterable()
      • Metadata.learnable
      • Metadata.transformation
  • neuralogic.core.constructs.predicate module
    • Predicate
      • Predicate.arity
      • Predicate.hidden
      • Predicate.name
      • Predicate.set_arity()
      • Predicate.special
      • Predicate.to_str()
    • PredicateMetadata
      • PredicateMetadata.metadata
      • PredicateMetadata.predicate
  • neuralogic.core.constructs.relation module
    • BaseRelation
      • BaseRelation.T
      • BaseRelation.attach_activation_function()
      • BaseRelation.function
      • BaseRelation.negated
      • BaseRelation.predicate
      • BaseRelation.terms
      • BaseRelation.to_str()
    • WeightedRelation
      • WeightedRelation.T
      • WeightedRelation.attach_activation_function()
      • WeightedRelation.fixed()
      • WeightedRelation.is_fixed
      • WeightedRelation.to_str()
      • WeightedRelation.weight
      • WeightedRelation.weight_name
  • neuralogic.core.constructs.rule module
    • Rule
      • Rule.body
      • Rule.head
      • Rule.metadata
      • Rule.to_str()
    • RuleBody
      • RuleBody.literals
      • RuleBody.metadata
  • neuralogic.core.constructs.term module
    • Constant
      • Constant.name
      • Constant.type
    • Variable
      • Variable.name
      • Variable.type
  • Module contents
• neuralogic.core.settings package
  • Submodules
  • neuralogic.core.settings.settings_proxy module
    • SettingsProxy
      • SettingsProxy.chain_pruning
      • SettingsProxy.clip_grad_norm
      • SettingsProxy.clip_grad_value
      • SettingsProxy.debug_exporting
      • SettingsProxy.default_fact_value
      • SettingsProxy.error_function
      • SettingsProxy.get_aggregation_function()
      • SettingsProxy.get_combination_function()
      • SettingsProxy.get_transformation_function()
      • SettingsProxy.grounder
      • SettingsProxy.initializer
      • SettingsProxy.initializer_const
      • SettingsProxy.initializer_uniform_scale
      • SettingsProxy.iso_value_compression
      • SettingsProxy.optimizer
      • SettingsProxy.prune_only_identities
      • SettingsProxy.relation_combination
      • SettingsProxy.relation_transformation
      • SettingsProxy.rule_aggregation
      • SettingsProxy.rule_combination
      • SettingsProxy.rule_transformation
      • SettingsProxy.to_json()
  • Module contents
    • Settings
      • Settings.chain_pruning
      • Settings.clip_grad_norm
      • Settings.clip_grad_value
      • Settings.create_disconnected_proxy()
      • Settings.create_proxy()
      • Settings.error_function
      • Settings.grounder
      • Settings.initializer
      • Settings.iso_value_compression
      • Settings.optimizer
      • Settings.prune_only_identities
• neuralogic.core.torch package
  • Submodules
  • neuralogic.core.torch.network_output module
  • neuralogic.core.torch.neural_module module
  • neuralogic.core.torch.tensor module
  • Module contents

Submodules

neuralogic.core.enums module

class Grounder(value)

Bases: Enum

BUP = 'BUP'

GRINGO = 'GRINGO'

neuralogic.core.model module

class Model(*, model_file: str | None = None)

Bases: NeuralModule

Model is a collection of rules and relations that define the structure of the neural model.

add_module(module: Module) → None

Expands the module into rules and adds them into the model.

Parameters:

module (Module) – The module to expand and add.

add_rule(rule: BaseRelation | WeightedRelation | Rule | PredicateMetadata) → None

Adds one rule to the model.

Parameters:

rule (ModelEntries) – The rule to add.

add_rules(rules: list[BaseRelation | WeightedRelation | Rule | PredicateMetadata]) → None

Adds multiple rules to the model.

Parameters:

rules (list[ModelEntries]) – The rules to add.

build(settings: Settings | None = None, torch: bool = False) → Model

Builds the model into a neural model.

Parameters:

• settings (Settings, optional) – The settings for building. Default: None.

• torch (bool) – Whether to use PyTorch backend. Default: False.

Returns:

The built model (self).

Return type:

Model

clone() → Model

derivable_queries(example: list[BaseRelation | Rule] | None = None) → list[BaseRelation] | dict

Returns all derivable queries for the provided example.

Parameters:

example (list[BaseRelation | Rule], optional) – The example to derive queries from. Default: None.

Returns:

The list of derivable queries.

Return type:

list[BaseRelation] | dict

load(path: str | Path) → None

Load model weights from a file saved by save().

The model must already be built with the same architecture that produced the saved file.

Parameters:

path (str | Path) – Path to the saved file.

q(query: BaseRelation, examples: list[BaseRelation | Rule] | None = None) → list[dict] | dict

query(query: BaseRelation, examples: list[BaseRelation | Rule] | None = None) → list[dict] | dict

Performs a query on the model with the provided examples.

Parameters:

• query (BaseRelation) – The query to perform.

• examples (list[BaseRelation | Rule], optional) – The examples to use for the query. Default: None.

Returns:

The list of query results (substitutions).

Return type:

list[dict] | dict

remove_duplicates() → None

Removes duplicates from the model.

save(path: str | Path) → None

Save the model weights to a file.

The model must be built before calling save(). To restore, rebuild the same architecture and call load().

Parameters:

path (str | Path) – Path to the output file (.pkl extension recommended).

neuralogic.core.neural_module module

class NeuralModule

Bases: object

NeuralModule is the base class for all neural models. It provides methods for grounding, building, training, and testing.

build_dataset(dataset: BaseDataset | GroundedDataset, *, batch_size: int = 1, learnable_facts: bool = False, progress: bool = False) → BuiltDataset

Builds (ground and neuralize) the provided dataset.

Parameters:

• dataset (Union[BaseDataset, GroundedDataset]) – The dataset to build.

• batch_size (int) – The batch size. Default: 1.

• learnable_facts (bool) – Whether facts are learnable. Default: False.

• progress (bool) – Whether to show progress. Default: False.

Returns:

The built dataset.

Return type:

BuiltDataset

build_static_dataset(dataset: Dataset, *, batch_size: int = 1, learnable_facts: bool = False, progress: bool = False) → StaticGraphDataset

Build a static-graph dataset from a logic Dataset.

Only the first sample is grounded and neuralized. The resulting StaticGraphDataset reuses the same neural graph for every sample, updating fact values via set_fact_value before each learning step.

Parameters:

• dataset (Dataset) – The dataset with one or more samples sharing identical structure.

• batch_size (int) – The batch size. Default: 1.

• learnable_facts (bool) – Whether facts are learnable. Default: False.

• progress (bool) – Whether to show progress. Default: False.

Return type:

StaticGraphDataset

draw(filename: str | None = None, show=True, img_type='png', value_detail: int = 0, graphviz_path: str | None = None, settings: DrawingSettings | None = None, *args, **kwargs)

fixed_state_dict() → dict

Returns the weights training does not touch, in the same shape as state_dict().

A fixed weight is a modelling choice rather than a parameter - an initial hidden state, say - so it is deliberately absent from state_dict(), which describes what training changes. Reading one is still a reasonable thing to want, and without this the only way was through the private Java model.

The library’s own internal constants sit at negative indices, the logical ONE among them. Those are not modelling choices and are left out.

Returns:

The fixed weights and their names.

Return type:

dict

forward(dataset)

ground(dataset: BaseDataset, *, batch_size: int = 1, learnable_facts: bool = False, progress: bool = False) → GroundedDataset

Grounds the provided dataset using the model’s settings.

Parameters:

• dataset (BaseDataset) – The dataset to ground.

• batch_size (int) – The batch size for grounding. Default: 1.

• learnable_facts (bool) – Whether facts are learnable. Default: False.

• progress (bool) – Whether to show progress. Default: False.

Returns:

The grounded dataset.

Return type:

GroundedDataset

load_fixed_state_dict(state_dict: dict)

Sets the weights training does not touch, from a fixed_state_dict() shaped dictionary.

Setting one is initialization, not learning, so this is separate from load_state_dict() - which skips fixed weights precisely because training must not move them.

Parameters:

state_dict (dict) – Fixed weights to set, keyed by weight index. Indices absent from the model are an error, and a learnable index is refused rather than quietly written.

load_state_dict(state_dict: dict)

loss(dataset) → float

The dataset’s loss, reduced the way the error function says.

This is the single number torch’s criterion hands back, and the quantity the optimizer is descending: the per-query errors summed and then divided by the batch’s total element count under reduction="mean", or left undivided under "sum".

It is deliberately separate from validate(), whose per-query values are not reduced across the batch - each is summed over its own components, which is torch’s reduction="none". Both are useful, and conflating them is what let a reported number drift away from the one being minimised once before.

Parameters:

dataset (Any) – The dataset to take the loss of.

Returns:

The reduced loss.

Return type:

float

parameters() → dict

Returns the model parameters.

Returns:

The model parameters.

Return type:

dict

reset_parameters()

state_dict() → dict

Returns the state dictionary of the model.

Returns:

The state dictionary (weights and weight names).

Return type:

dict

tensor_parameters()

test(dataset) → list | float

Tests the model on the provided dataset.

Parameters:

dataset (Any) – The dataset to test on.

Returns:

The test results (outputs).

Return type:

Union[Value, List[Value]]

train(dataset, epochs: int = 1) → list | float

Trains the model on the provided dataset.

Parameters:

• dataset (Any) – The dataset to train on. Can be a Dataset, GroundedDataset, BuiltDataset, StaticGraphDataset, or a list of samples.

• epochs (int) – The number of epochs to train. Default: 1.

Returns:

The training results (target, output, error).

Return type:

Union[Tuple[Value, Value, Value], List[Tuple[Value, Value, Value]]]

train_with_metrics(dataset, epochs: int = 1, metrics=None)

Trains like train() and also computes Java deep metrics.

Parameters:

• dataset (Any) – Same inputs as train().

• epochs (int) – Number of epochs. Default: 1.

• metrics (Sequence[str] or None) – Java metric names to compute (auc_roc, auc_pr, best_accuracy, best_threshold, saturation).

Returns:

(results, java_metrics) where results has the same shape as train() and java_metrics is a dict[str, float].

Return type:

tuple

validate(dataset) → list | float

Evaluates the model on the provided dataset and reports the error, without training on it.

Same shape of result as train(), so a validation loss can be computed the same way, but nothing is backpropagated and the optimizer is not stepped.

Parameters:

dataset (Any) – The dataset to validate on.

Returns:

The validation results (target, output, error).

Return type:

Union[Tuple[Value, Value, Value], List[Tuple[Value, Value, Value]]]

validate_with_metrics(dataset, metrics=None)

Evaluates like validate() and also computes Java deep metrics.

Parameters:

• dataset (Any) – Same inputs as validate().

• metrics (Sequence[str] or None) – Java metric names to compute (auc_roc, auc_pr, best_accuracy, best_threshold, saturation).

Returns:

(results, java_metrics) where results has the same shape as validate() and java_metrics is a dict[str, float].

Return type:

tuple

vectorize(dataset: BaseDataset)

Builds a PyTorch vectorized network from the provided dataset.

Parameters:

dataset (BaseDataset) – The dataset to build and vectorize.

Returns:

The vectorized PyTorch model.

Return type:

torch.nn.Module

neuralogic.core.sources module

class Sources(sources: Any)

Bases: object

Represents the logic sources (models, examples, queries) for the NeuraLogic backend.

static from_args(args: list[str], settings: SettingsProxy) → Sources

Creates Sources from command line arguments and settings.

Parameters:

• args (List[str]) – The command line arguments.

• settings (SettingsProxy) – The settings proxy.

Returns:

The created Sources object.

Return type:

Sources

static from_settings(settings: SettingsProxy) → Sources

Creates Sources from the provided settings.

Parameters:

settings (SettingsProxy) – The settings proxy.

Returns:

The created Sources object.

Return type:

Sources

to_json() → str

Exports the sources to a JSON string.

Returns:

The JSON representation of the sources.

Return type:

str

Module contents

class Aggregation

Bases: object

Collection of aggregation functions. Aggregation functions are used to aggregate multiple inputs, typically from different groundings of the same rule.

AVG: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

CONCAT: ConcatAggregation = <neuralogic.core.constructs.function.concat.ConcatAggregation object>

COUNT: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

MAX: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

MIN: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

SOFTMAX: SoftmaxAggregation = <neuralogic.core.constructs.function.softmax.SoftmaxAggregation object>

SUM: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

class BuiltDataset(samples: list[NeuralSample], batch_size: int)

Bases: object

BuiltDataset represents an already built dataset - that is, a dataset that has been grounded and neuralized.

load_state_dict(state_dict: dict, strict: bool = True) → IncompatibleKeys

Sets this dataset’s example-fact parameters from a state_dict() shaped dictionary.

With strict=False this is also how a parameter reaches a dataset it was not trained on - the embeddings learned for the training set, carried onto the test set for the constants the two share:

test_data.load_state_dict(train_data.state_dict(), strict=False)

A constant the training set never saw keeps whatever its example wrote, untrained, and comes back in missing_keys; a trained parameter with no fact to attach to here comes back in unexpected_keys. Both are ordinary in that use and neither is in the round trip of one dataset, which is why strict defaults to refusing them.

Parameters:

• state_dict (dict) – {"weights": {literal: value}}.

• strict (bool) – Whether the literals must match this dataset’s exactly, as in torch. Default: True.

Returns:

missing_keys - this dataset’s learnable facts the dictionary said nothing about - and unexpected_keys - literals in the dictionary this dataset has no learnable fact for.

Return type:

IncompatibleKeys

Raises:

ValueError – Under strict, if either list is non-empty: the saved parameters and the data have drifted apart, and carrying on would leave a model half restored. Always, if two literals that share one weight are given different values - facts share a weight when the example named it, and then only one of the two values could survive, which one being an accident of iteration order.

state_dict() → dict

The learnable values this dataset’s own example facts carry, keyed by ground literal.

A value written on an example fact and made learnable with learnable_facts=True is a real parameter - it trains - but it belongs to the data, not to the template, so it is not in the model’s state_dict() and saving the model does not save it. This is where it is.

The key is the ground literal (emb(a)) because nothing else survives a rebuild: the weight’s index continues a counter that keeps running, so building the same dataset twice on one model gives the parameters indices 1, 2 and then 5, 6, and the generated weight name is w plus that index.

Returns:

{"weights": {literal: value}}, empty when the dataset was not built with learnable_facts=True.

Return type:

dict

class Combination

Bases: object

Collection of combination functions. Combination functions are used to combine multiple inputs into a single output, often as part of a rule body or for combining multiple rules.

AVG: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

CONCAT: ConcatCombination = <neuralogic.core.constructs.function.concat.ConcatCombination object>

COSSIM: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

COUNT: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

CROSSSUM: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

ELPRODUCT: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

MAX: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

MIN: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

PRODUCT: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

SOFTMAX: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

SPARSEMAX: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

SUM: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

class F

Bases: object

Utility class providing a flat namespace for common functions. It includes transformation, combination, and aggregation functions.

avg: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

avg_agg: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

concat: ConcatCombination = <neuralogic.core.constructs.function.concat.ConcatCombination object>

concat_agg: ConcatAggregation = <neuralogic.core.constructs.function.concat.ConcatAggregation object>

cossim: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

count: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

count_agg: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

crossum: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

elproduct: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

exp: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

identity: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

inverse: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

leaky_relu: TransformationFunction = <neuralogic.core.constructs.function.leaky_relu.LeakyReLuTransformation object>

log: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

lukasiewicz: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

max: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

max_agg: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

min: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

min_agg: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

norm: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

product: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

relu: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

reshape: Reshape = <neuralogic.core.constructs.function.reshape.Reshape object>

reverse: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

sigmoid: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

signum: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

slice: Slice = <neuralogic.core.constructs.function.slice.Slice object>

softmax: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

softmax_agg: SoftmaxAggregation = <neuralogic.core.constructs.function.softmax.SoftmaxAggregation object>

softmax_comb: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

sparsemax: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

sparsemax_comb: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

sqrt: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

sum: CombinationFunction = <neuralogic.core.constructs.function.function.CombinationFunction object>

sum_agg: AggregationFunction = <neuralogic.core.constructs.function.function.AggregationFunction object>

tanh: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

transp: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

class GroundedDataset(groundings, builder: Builder)

Bases: object

GroundedDataset represents grounded examples that are not neuralized yet.

neuralize(*, batch_size: int = 1, progress: bool = False) → BuiltDataset

class Grounder(value)

Bases: Enum

BUP = 'BUP'

GRINGO = 'GRINGO'

class Metadata(learnable: bool | None = None, transformation: TransformationFunction | CombinationFunction | None = None, combination: CombinationFunction | None = None, aggregation: AggregationFunction | None = None, duplicate_grounding: bool | None = None)

Bases: object

Represents metadata for a logic construct (e.g., rule, predicate).

Metadata can specify properties like learnability, transformation functions, aggregation functions, and combination functions.

aggregation

combination

combine(other: Metadata) → Metadata

Combines this metadata with another Metadata object. Values from the other object take precedence.

Parameters:

other (Metadata) – The other Metadata object to combine with.

Returns:

A new combined Metadata object.

Return type:

Metadata

copy() → Metadata

Returns a shallow copy of the metadata.

Returns:

The copy of the metadata.

Return type:

Metadata

duplicate_grounding

static from_iterable(iterable: Iterable[Any]) → Metadata

Creates a Metadata object from an iterable of functions or values.

Parameters:

iterable (Iterable) – The iterable containing metadata entries.

Returns:

The created Metadata object.

Return type:

Metadata

learnable

transformation

class Model(*, model_file: str | None = None)

Bases: NeuralModule

Model is a collection of rules and relations that define the structure of the neural model.

add_module(module: Module) → None

Expands the module into rules and adds them into the model.

Parameters:

module (Module) – The module to expand and add.

add_rule(rule: BaseRelation | WeightedRelation | Rule | PredicateMetadata) → None

Adds one rule to the model.

Parameters:

rule (ModelEntries) – The rule to add.

add_rules(rules: list[BaseRelation | WeightedRelation | Rule | PredicateMetadata]) → None

Adds multiple rules to the model.

Parameters:

rules (list[ModelEntries]) – The rules to add.

build(settings: Settings | None = None, torch: bool = False) → Model

Builds the model into a neural model.

Parameters:

• settings (Settings, optional) – The settings for building. Default: None.

• torch (bool) – Whether to use PyTorch backend. Default: False.

Returns:

The built model (self).

Return type:

Model

clone() → Model

derivable_queries(example: list[BaseRelation | Rule] | None = None) → list[BaseRelation] | dict

Returns all derivable queries for the provided example.

Parameters:

example (list[BaseRelation | Rule], optional) – The example to derive queries from. Default: None.

Returns:

The list of derivable queries.

Return type:

list[BaseRelation] | dict

load(path: str | Path) → None

Load model weights from a file saved by save().

The model must already be built with the same architecture that produced the saved file.

Parameters:

path (str | Path) – Path to the saved file.

q(query: BaseRelation, examples: list[BaseRelation | Rule] | None = None) → list[dict] | dict

query(query: BaseRelation, examples: list[BaseRelation | Rule] | None = None) → list[dict] | dict

Performs a query on the model with the provided examples.

Parameters:

• query (BaseRelation) – The query to perform.

• examples (list[BaseRelation | Rule], optional) – The examples to use for the query. Default: None.

Returns:

The list of query results (substitutions).

Return type:

list[dict] | dict

remove_duplicates() → None

Removes duplicates from the model.

save(path: str | Path) → None

Save the model weights to a file.

The model must be built before calling save(). To restore, rebuild the same architecture and call load().

Parameters:

path (str | Path) – Path to the output file (.pkl extension recommended).

class Rule(head: BaseRelation, body: RuleBody | Iterable[BodyItem] | BodyItem)

Bases: object

Represents a rule in the model, consisting of a head and a body.

body: list[BodyItem] | FContainer

head

metadata: Metadata | None

to_str(_: bool = False) → str

class RuleBody(lit1: BaseRelation, lit2: BaseRelation)

Bases: object

Represents the body of a rule, which is a collection of literals.

literals: list['BaseRelation' | FContainer]

metadata: Metadata | None

class Settings(*, optimizer: Optimizer = <neuralogic.nn.optim.adam.Adam object>, error_function: ErrorFunction = <neuralogic.nn.loss.MSE object>, initializer: Initializer = <neuralogic.nn.init.Glorot object>, iso_value_compression: bool = True, chain_pruning: bool = True, prune_only_identities: bool = False, grounder: Grounder = Grounder.BUP, clip_grad_norm: float | None = None, clip_grad_value: float | None = None)

Bases: object

property chain_pruning: bool

property clip_grad_norm: float | None

property clip_grad_value: float | None

create_disconnected_proxy() → SettingsProxy

create_proxy() → SettingsProxy

property error_function: ErrorFunction

property grounder: Grounder

property initializer: Initializer

property iso_value_compression: bool

property optimizer: Optimizer

property prune_only_identities: bool

class SettingsProxy(*, optimizer: Optimizer, error_function: ErrorFunction, initializer: Initializer, iso_value_compression: bool, chain_pruning: bool, prune_only_identities: bool, grounder: Grounder, clip_grad_norm: float | None = None, clip_grad_value: float | None = None)

Bases: object

Proxy class for the Java Settings object.

It provides a Pythonic interface to configure various parameters of the NeuraLogic backend, such as optimizers, initializers, error functions, and grounding algorithms.

property chain_pruning: bool

Whether to use chain pruning (reducing redundant chains of operations).

property clip_grad_norm: float | None

The global gradient norm the whole gradient is rescaled down to before each step.

property clip_grad_value: float | None

The bound every gradient element is clamped to before each step.

property debug_exporting: bool

property default_fact_value: float

property error_function: Any

The error function used for training.

get_aggregation_function(aggregation: Aggregation) → Any

get_combination_function(combination: Combination) → Any

Returns the Java combination function for the given Python enum value.

Parameters:

combination (Combination) – The combination function enum value.

Returns:

The Java combination function object.

Return type:

Any

get_transformation_function(transformation: Transformation) → Any

property grounder: Any

The grounding algorithm to use.

property initializer: Any

The weight initializer used for model parameters.

property initializer_const: float

property initializer_uniform_scale: float

property iso_value_compression: bool

Whether to use iso-value compression.

property optimizer: Optimizer

The optimizer used for training.

property prune_only_identities: bool

property relation_combination: CombinationFunction

property relation_transformation: TransformationFunction

property rule_aggregation: AggregationFunction

property rule_combination: CombinationFunction

property rule_transformation: TransformationFunction

to_json() → str

Exports the settings to a JSON string.

Returns:

The JSON representation of the settings.

Return type:

str

class Transformation

Bases: object

Collection of transformation functions. Transformation functions are applied element-wise or as join operations (e.g., Softmax, Transpose).

EXP: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

IDENTITY: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

INVERSE: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

LEAKY_RELU: TransformationFunction = <neuralogic.core.constructs.function.leaky_relu.LeakyReLuTransformation object>

LOG: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

LUKASIEWICZ: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

NORM: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

RELU: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

RESHAPE: Reshape = <neuralogic.core.constructs.function.reshape.Reshape object>

REVERSE: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

SIGMOID: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

SIGNUM: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

SLICE: Slice = <neuralogic.core.constructs.function.slice.Slice object>

SOFTMAX: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

SPARSEMAX: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

SQRT: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

TANH: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>

TRANSP: TransformationFunction = <neuralogic.core.constructs.function.function.TransformationFunction object>