neuralogic 0.8.1.dev0__tar.gz → 0.8.3.dev0__tar.gz

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralogic
-Version: 0.8.1.dev0
+Version: 0.8.3.dev0
 Summary: PyNeuraLogic lets you use Python to create Differentiable Logic Programs.
 Home-page: https://github.com/LukasZahradnik/PyNeuraLogic
 Author: Lukáš Zahradník
@@ -155,7 +155,8 @@ $ pip install neuralogic
 ```
 
 
-### Prerequisites
+<details>
+<summary>Prerequisites</summary>
 
 To use PyNeuraLogic, you need to install the following prerequisites:
 
@@ -168,6 +169,9 @@ Java >= 1.8
 >
 > In case you want to use visualization provided in the library, it is required to have [Graphviz](https://graphviz.org/download/) installed.
 
+</details>
+
+
 <br />
 
 ## 📦 Predefined Modules
@@ -195,6 +199,12 @@ It contains, for example, predefined modules for:
 <br />
 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/LukasZahradnik/PyNeuraLogic/blob/master/examples/DistinguishingNonRegularGraphs.ipynb) [Distinguishing non-regular graphs](https://github.com/LukasZahradnik/PyNeuraLogic/blob/master/examples/DistinguishingNonRegularGraphs.ipynb)
 
+## 🤝 Community & Support
+
+- [GitHub Issues](https://github.com/LukasZahradnik/PyNeuraLogic/issues) for bug reports and feature requests
+- [Discussions](https://github.com/LukasZahradnik/PyNeuraLogic/discussions) for questions and ideas
+- [Contributing Guide](CONTRIBUTING.md) if you want to help improve PyNeuraLogic
+
 ## 📝 Papers
 
 - [Beyond Graph Neural Networks with Lifted Relational Neural Networks](https://arxiv.org/abs/2007.06286) Machine Learning Journal, 2021

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/README.md

@@ -115,7 +115,8 @@ $ pip install neuralogic
 ```
 
 
-### Prerequisites
+<details>
+<summary>Prerequisites</summary>
 
 To use PyNeuraLogic, you need to install the following prerequisites:
 
@@ -128,6 +129,9 @@ Java >= 1.8
 >
 > In case you want to use visualization provided in the library, it is required to have [Graphviz](https://graphviz.org/download/) installed.
 
+</details>
+
+
 <br />
 
 ## 📦 Predefined Modules
@@ -155,6 +159,12 @@ It contains, for example, predefined modules for:
 <br />
 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/LukasZahradnik/PyNeuraLogic/blob/master/examples/DistinguishingNonRegularGraphs.ipynb) [Distinguishing non-regular graphs](https://github.com/LukasZahradnik/PyNeuraLogic/blob/master/examples/DistinguishingNonRegularGraphs.ipynb)
 
+## 🤝 Community & Support
+
+- [GitHub Issues](https://github.com/LukasZahradnik/PyNeuraLogic/issues) for bug reports and feature requests
+- [Discussions](https://github.com/LukasZahradnik/PyNeuraLogic/discussions) for questions and ideas
+- [Contributing Guide](CONTRIBUTING.md) if you want to help improve PyNeuraLogic
+
 ## 📝 Papers
 
 - [Beyond Graph Neural Networks with Lifted Relational Neural Networks](https://arxiv.org/abs/2007.06286) Machine Learning Journal, 2021

neuralogic-0.8.3.dev0/neuralogic/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.8.3.dev"

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/builder/builder.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 import jpype
 from tqdm.autonotebook import tqdm
 
@@ -9,7 +7,7 @@ from neuralogic.core.settings import SettingsProxy
 from neuralogic.core.sources import Sources
 
 
-def stream_to_list(stream) -> List:
+def stream_to_list(stream) -> list:
     return list(stream.collect(jpype.JClass("java.util.stream.Collectors").toList()))
 
 
@@ -52,37 +50,44 @@ class Builder:
 
         return template
 
-    def ground_from_sources(self, parsed_template, sources: Sources):
-        return self._ground(parsed_template, sources, None)
+    def ground_from_sources(self, parsed_template, sources: Sources, progress: bool):
+        if not progress:
+            return self._ground(parsed_template, sources, None, None)
+        with tqdm(total=None, desc="Grounding", unit=" samples", dynamic_ncols=True) as pbar:
+            return self._ground(parsed_template, sources, None, self._callback(pbar))
 
-    def ground_from_logic_samples(self, parsed_template, logic_samples):
-        return self._ground(parsed_template, None, logic_samples)
+    def ground_from_logic_samples(self, parsed_template, logic_samples, progress: bool):
+        if not progress:
+            return self._ground(parsed_template, None, logic_samples, None)
+        with tqdm(total=len(logic_samples), desc="Grounding", unit=" samples", dynamic_ncols=True) as pbar:
+            return self._ground(parsed_template, None, logic_samples, self._callback(pbar))
 
-    def _ground(self, parsed_template, sources: Optional[Sources], logic_samples) -> List[NeuralSample]:
+    def _ground(self, parsed_template, sources: Sources | None, logic_samples, callback):
         if sources is not None:
-            ground_pipeline = self.example_builder.buildGroundings(parsed_template, sources.sources)
+            ground_pipeline = self.example_builder.buildGroundings(parsed_template, sources.sources, callback)
         else:
             logic_samples = jpype.java.util.ArrayList(logic_samples).stream()
-            ground_pipeline = self.example_builder.buildGroundings(parsed_template, logic_samples)
+            ground_pipeline = self.example_builder.buildGroundings(parsed_template, logic_samples, callback)
 
         ground_pipeline.execute(None if sources is None else sources.sources)
+        groundings = ground_pipeline.get()
 
-        return ground_pipeline.get()
+        if callback is not None:
+            return groundings.collect(self.collectors.toList())
+        return groundings
 
-    def neuralize(self, groundings, progress: bool, length: Optional[int]) -> List[NeuralSample]:
+    def neuralize(self, groundings, progress: bool, length: int | None) -> list[NeuralSample]:
         if not progress:
             return self._neuralize(groundings, None)
         with tqdm(total=length, desc="Building", unit=" samples", dynamic_ncols=True) as pbar:
             return self._neuralize(groundings, self._callback(pbar))
 
-    def _neuralize(self, groundings, callback) -> List[NeuralSample]:
-        neuralize_pipeline = self.example_builder.neuralize(groundings.stream(), callback)
+    def _neuralize(self, groundings, callback) -> list[NeuralSample]:
+        neuralize_pipeline = self.example_builder.neuralize(groundings, callback)
         neuralize_pipeline.execute(None)
+        logic_samples = neuralize_pipeline.get().collect(self.collectors.toList())
 
-        samples = neuralize_pipeline.get()
-        logic_samples = samples.collect(self.collectors.toList())
-
-        return [NeuralSample(sample, grounding) for sample, grounding in zip(logic_samples, groundings)]
+        return [NeuralSample(sample) for sample in logic_samples]
 
     def build_model(self, parsed_template, settings: SettingsProxy):
         neural_model = self.neural_model(parsed_template.getAllWeights(), settings.settings)

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/builder/components.py

@@ -1,7 +1,6 @@
 import enum
 from typing import Any, Dict, Optional
 
-from neuralogic.core.settings.settings_proxy import SettingsProxy
 from neuralogic.core.constructs.java_objects import ValueFactory
 from neuralogic.utils.visualize import draw_sample, draw_grounding
 
@@ -32,17 +31,9 @@ class Atom:
         return self._predicate
 
     @property
-    def arityy(self):
+    def arity(self):
         return self._arity
 
-    @property
-    def value(self):
-        return ValueFactory.from_java(self._atom.getRawState().getValue(), SettingsProxy.number_format())
-
-    @property
-    def gradient(self):
-        return ValueFactory.from_java(self._atom.getRawState().getGradient(), SettingsProxy.number_format())
-
     def node_type(self) -> NeuronType:
         return NeuronType(self._atom.getClass().getSimpleName())
 
@@ -51,14 +42,26 @@ class Atom:
 
 
 class Neuron(Atom):
-    pass
+    def __init__(self, neuron, substitutions: Dict):
+        self.substitutions = substitutions
+        self._atom = neuron
+
+        self._predicate = neuron.getName()
+        self._arity = len(substitutions)
+
+    @property
+    def value(self):
+        return ValueFactory.from_java(self._atom.getRawState().getValue())
+
+    @property
+    def gradient(self):
+        return ValueFactory.from_java(self._atom.getRawState().getGradient())
 
 
 class NeuralSample:
-    __slots__ = "_java_sample", "grounding", "_neurons"
+    __slots__ = "_java_sample", "_neurons"
 
-    def __init__(self, sample, grounding):
-        self.grounding = Grounding(grounding)
+    def __init__(self, sample):
         self._java_sample = sample
         self._neurons = None
 
@@ -70,7 +73,7 @@ class NeuralSample:
 
     @property
     def target(self):
-        return ValueFactory.from_java(self._java_sample.target, SettingsProxy.number_format())
+        return ValueFactory.from_java(self._java_sample.target)
 
     def get_neurons(self, literal, neuron_type: NeuronType | None = NeuronType.Atom):
         literal_name = literal.predicate.name

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/builder/dataset.py

@@ -29,32 +29,18 @@ class GroundedDataset:
     __slots__ = "_groundings", "_groundings_list", "_builder"
 
     def __init__(self, groundings, builder: Builder):
-        self._groundings = groundings
-        self._groundings_list = None
         self._builder = builder
-
-    def _to_list(self):
-        if self._groundings_list is None:
-            self._groundings = self._groundings.collect(jpype.JClass("java.util.stream.Collectors").toList())
-            self._groundings_list = [Grounding(g) for g in self._groundings]
+        self._groundings = groundings
+        self._groundings_list = [Grounding(g) for g in self._groundings]
 
     def __getitem__(self, item) -> Grounding:
-        self._to_list()
-        if self._groundings_list is None:
-            raise ValueError
-
         return self._groundings_list[item]
 
     def __len__(self) -> int:
-        self._to_list()
-        if self._groundings_list is None:
-            return 0
         return len(self._groundings_list)
 
     def __iter__(self):
-        self._to_list()
         return iter(self._groundings_list)
 
-    def neuralize(self, *, progress: bool = False) -> list[NeuralSample]:
-        self._to_list()
-        return self._builder.neuralize(self._groundings, progress, len(self))
+    def neuralize(self, *, batch_size: int = 1, progress: bool = False) -> BuiltDataset:
+        return BuiltDataset(self._builder.neuralize(self._groundings.stream(), progress, len(self)), batch_size)

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/builder/dataset_builder.py

@@ -1,4 +1,4 @@
-from typing import Union, Set, Dict, List
+from typing import Union, List
 
 import jpype
 
@@ -32,8 +32,6 @@ class DatasetBuilder:
         self.query_counter = 0
         self.examples_counter = 0
 
-        self.hooks: Dict[str, Set] = {}
-
     def build_queries(self, queries, query_builder):
         logic_samples = []
         one_query_per_example = True
@@ -114,13 +112,17 @@ class DatasetBuilder:
         *,
         batch_size: int = 1,
         learnable_facts: bool = False,
-    ) -> GroundedDataset:
+        progress: bool = False,
+        raw_groundings: bool = False,
+    ):
         """Grounds the dataset
 
         :param dataset:
         :param settings:
         :param batch_size:
         :param learnable_facts:
+        :param progress:
+        :param raw_groundings:
         :return:
         """
         if isinstance(dataset, datasets.ConvertibleDataset):
@@ -129,6 +131,8 @@ class DatasetBuilder:
                 settings,
                 batch_size=batch_size,
                 learnable_facts=learnable_facts,
+                progress=progress,
+                raw_groundings=raw_groundings,
             )
 
         if batch_size > 1:
@@ -172,7 +176,7 @@ class DatasetBuilder:
                 queries, examples, one_query_per_example, example_queries
             )
 
-            groundings = builder.ground_from_logic_samples(self.parsed_template, logic_samples)
+            groundings = builder.ground_from_logic_samples(self.parsed_template, logic_samples, progress)
 
             self.java_factory.weight_factory = weight_factory
         elif isinstance(dataset, datasets.FileDataset):
@@ -186,11 +190,16 @@ class DatasetBuilder:
                 args.extend(["-e", dataset.examples_file])
             sources = Sources.from_args(args, settings)
 
-            groundings = builder.ground_from_sources(self.parsed_template, sources)
+            groundings = builder.ground_from_sources(self.parsed_template, sources, progress)
         else:
             raise NotImplementedError
 
-        return GroundedDataset(groundings, builder)
+        if raw_groundings:
+            return groundings
+        if progress:
+            return GroundedDataset(groundings, builder)
+
+        return GroundedDataset(groundings.collect(builder.collectors.toList()), builder)
 
     def build_dataset(
         self,
@@ -211,12 +220,13 @@ class DatasetBuilder:
         :return:
         """
         if not isinstance(dataset, GroundedDataset):
-            grounded_dataset = self.ground_dataset(
-                dataset, settings, batch_size=batch_size, learnable_facts=learnable_facts
+            groundings = self.ground_dataset(
+                dataset, settings, batch_size=batch_size, learnable_facts=learnable_facts, raw_groundings=True,
             )
-        else:
-            grounded_dataset = dataset
-        return BuiltDataset(grounded_dataset.neuralize(progress=progress), batch_size)
+
+            samples = Builder(settings).neuralize(groundings, progress, None)
+            return BuiltDataset(samples, batch_size)
+        return dataset.neuralize(batch_size=batch_size, progress=progress)
 
     @staticmethod
     def merge_queries_with_examples(queries, examples, one_query_per_example, example_queries=True):
@@ -282,8 +292,15 @@ class DatasetBuilder:
             idx = id(sample.example)
 
             if idx not in example_dict:
-                queries_dict[idx] = [sample.query]
+                if isinstance(sample.query, list):
+                    queries_dict[idx] = [*sample.query]
+                else:
+                    queries_dict[idx] = [sample.query]
                 example_dict[idx] = sample.example
+                continue
+
+            if isinstance(sample.query, list):
+                queries_dict[idx].extend(sample.query)
             else:
                 queries_dict[idx].append(sample.query)
         return example_dict.values(), queries_dict.values()

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/constructs/java_objects.py

@@ -21,14 +21,13 @@ class ValueFactory:
         self.matrix_value = jpype.JClass("cz.cvut.fel.ida.algebra.values.MatrixValue")
 
     @staticmethod
-    def from_java(value, number_format):
+    def from_java(value):
         size = list(value.size())
-
         if len(size) == 0 or size[0] == 0:
             return float(value.get(0))
-        elif len(size) == 1 or size[0] == 1 or size[1] == 1:
-            return list(float(x) for x in value.values)
-        return json.loads(str(value.toString(number_format)))
+        if len(size) == 2 and size[1] != 1:
+            return np.array(memoryview(value.getAsArray())).reshape(size).tolist()
+        return np.array(memoryview(value.getAsArray())).tolist()
 
     def get_value(self, weight):
         if isinstance(weight, (float, int)) or np.ndim(weight) == 0:
@@ -48,7 +47,7 @@ class ValueFactory:
                 else:
                     value = self.matrix_value(weight[0], weight[1])
             else:
-                raise NotImplementedError
+                raise NotImplementedError(f"dimensions of size {len(weight)} are not supported. If you wanted to provide tensor as weight, wrap it into a list first")
             return False, value
 
         if isinstance(weight, (Sequence, np.ndarray, Iterable)):
@@ -373,7 +372,7 @@ class JavaFactory:
             body_relation.append(self.get_relation(relation, variable_factory))
 
         for index in all_diff_index:
-            terms = {term for term in body_relation[index].terms}
+            terms = {term for term in body_relation[index].terms if term is not Ellipsis}
             terms.update(term for term in all_variables)
 
             body_relation[index] = self.get_relation(R.special.alldiff(terms), variable_factory)

{neuralogic-0.8.1.dev0 → neuralogic-0.8.3.dev0}/neuralogic/core/neural_module.py

@@ -1,11 +1,9 @@
-from typing import Union, Callable, Dict, Any, Set, Collection, List, Tuple
-import json
+from typing import Collection
 
 import jpype
 
 from neuralogic.setup import is_initialized, initialize
 from neuralogic.core.constructs.java_objects import ValueFactory
-from neuralogic.core.constructs.relation import BaseRelation
 from neuralogic.core.builder import DatasetBuilder
 from neuralogic.core.builder.dataset import BuiltDataset, GroundedDataset
 from neuralogic.core.settings.settings_proxy import SettingsProxy
@@ -15,7 +13,7 @@ from neuralogic.dataset.base import BaseDataset
 from neuralogic.utils.visualize import draw_model
 
 
-Value = Union[List, float]
+Value = list | float
 
 
 class NeuralModule:
@@ -26,22 +24,6 @@ class NeuralModule:
         self._need_sync = False
         self._value_factory = ValueFactory()
 
-        @jpype.JImplements(
-            jpype.JClass("cz.cvut.fel.ida.neural.networks.computation.iteration.actions.PythonHookHandler")
-        )
-        class HookHandler:
-            def __init__(self, module: "NeuralModule"):
-                self.module = module
-
-            @jpype.JOverride
-            def handleHook(self, hook, value):
-                self.module._run_hook(hook, json.loads(value))
-
-        self._hooks: Dict[str, Set[Callable]] = {}
-        self._hooks_set = False
-
-        self._hook_handler = HookHandler(self)
-
         self._parsed_template = None
         self._dataset_builder: DatasetBuilder | None = None
         self._settings: SettingsProxy | None = None
@@ -56,10 +38,7 @@ class NeuralModule:
 
         self._weight_updater = None
         self._tensor_parameters = None
-
-        from neuralogic.core.torch.neural_module import TorchNeuralModule
-
-        self._torch_module = TorchNeuralModule()
+        self._torch_module = None
 
     def ground(
         self,
@@ -67,6 +46,7 @@ class NeuralModule:
         *,
         batch_size: int = 1,
         learnable_facts: bool = False,
+        progress: bool = False,
     ) -> GroundedDataset:
         if self._dataset_builder is None or self._settings is None:
             raise ValueError("template is not built")
@@ -76,11 +56,12 @@ class NeuralModule:
             self._settings,
             batch_size=batch_size,
             learnable_facts=learnable_facts,
+            progress=progress,
         )
 
     def build_dataset(
         self,
-        dataset: Union[BaseDataset, GroundedDataset],
+        dataset: BaseDataset | GroundedDataset,
         *,
         batch_size: int = 1,
         learnable_facts: bool = False,
@@ -98,12 +79,8 @@ class NeuralModule:
         )
 
     def __call__(self, dataset=None):
-        self._set_hooks()
         samples, _ = self._dataset_to_samples(dataset)
-        sample_collection = samples
-
-        if not isinstance(samples, Collection):
-            sample_collection = [samples]
+        sample_collection = samples if isinstance(samples, Collection) else [samples]
 
         for sample in sample_collection:
             self._trainer.invalidateSample(self._invalidation, sample._java_sample)
@@ -111,7 +88,6 @@ class NeuralModule:
         results = [
             self._value_factory.from_java(
                 self._trainer.evaluateSample(self._evaluation, sample._java_sample).getOutput(),
-                SettingsProxy.number_format(),
             )
             for sample in sample_collection
         ]
@@ -124,47 +100,55 @@ class NeuralModule:
     def forward(self, dataset):
         return self(dataset)
 
-    def train(self, dataset, epochs: int = 1) -> Tuple[Value, int]:
-        self._set_hooks()
+    def train(self, dataset, epochs: int = 1) -> Value:
         samples, batch_size = self._dataset_to_samples(dataset)
 
         if not isinstance(samples, Collection):
             result = self._strategy.learnSample(samples._java_sample)
-            res = json.loads(str(result)), 1
+            res = (
+                ValueFactory.from_java(result.getTarget()),
+                ValueFactory.from_java(result.getOutput()),
+                ValueFactory.from_java(result.errorValue()),
+            )
         else:
             sample_array = jpype.java.util.ArrayList([sample._java_sample for sample in samples])
             results = self._strategy.learnSamples(sample_array, epochs, batch_size)
-            res = json.loads(str(results)), len(samples)
+            res = [
+                (
+                    ValueFactory.from_java(result.getTarget()),
+                    ValueFactory.from_java(result.getOutput()),
+                    ValueFactory.from_java(result.errorValue()),
+                ) for result in results
+            ]
 
         self._update_tensor_parameters()
         return res
 
     def test(self, dataset) -> Value:
-        self._set_hooks()
         samples, batch_size = self._dataset_to_samples(dataset)
 
         if not isinstance(samples, Collection):
-            return json.loads(str(self._strategy.evaluateSample(samples._java_sample)))
+            return ValueFactory.from_java(self._strategy.evaluateSample(samples._java_sample))
 
         sample_array = jpype.java.util.ArrayList([sample._java_sample for sample in samples])
-
         results = self._strategy.evaluateSamples(sample_array, batch_size)
-        return json.loads(str(results))
+
+        return [ValueFactory.from_java(result) for result in results]
 
     def reset_parameters(self):
         self._strategy.resetParameters()
 
-    def parameters(self) -> Dict:
+    def parameters(self) -> dict:
         return self.state_dict()
 
-    def state_dict(self) -> Dict:
+    def state_dict(self) -> dict:
         weights = self._neural_model.getAllWeights()
         weights_dict = {}
         weight_names = {}
 
         for weight in weights:
             if weight.isLearnable:
-                weights_dict[weight.index] = ValueFactory.from_java(weight.value, SettingsProxy.number_format())
+                weights_dict[weight.index] = ValueFactory.from_java(weight.value)
                 weight_names[weight.index] = weight.name
         return {
             "weights": weights_dict,
@@ -188,7 +172,7 @@ class NeuralModule:
         if self._torch_module is not None:
             self._torch_module.update_tensor_parameters(self._tensor_parameters)
 
-    def load_state_dict(self, state_dict: Dict):
+    def load_state_dict(self, state_dict: dict):
         self._sync_template(state_dict, self._neural_model.getAllWeights())
 
         if self._torch_module is not None:
@@ -204,51 +188,25 @@ class NeuralModule:
         *args,
         **kwargs,
     ):
+        if self._dataset_builder is None or self._settings is None:
+            raise ValueError("template is not built")
         return draw_model(self, filename, show, img_type, value_detail, graphviz_path, *args, **kwargs)
 
-    def set_hooks(self, hooks):
-        self._hooks_set = len(hooks) != 0
-        self._hooks = hooks
-
-    def add_hook(self, relation: Union[BaseRelation, str], callback: Callable[[Any], None]):
-        """Hooks the callable to be called with the relation's value as an argument when the value of
-        the relation is being calculated.
-
-        :param relation:
-        :param callback:
-        :return:
-        """
-        name = str(relation)
-
-        if isinstance(relation, BaseRelation):
-            name = name[:-1]
-
-        if name not in self._hooks:
-            self._hooks[name] = {callback}
-        else:
-            self._hooks[name].add(callback)
-
-    def remove_hook(self, relation: Union[BaseRelation, str], callback):
-        """Removes the callable from the relation's hooks
-
-        :param relation:
-        :param callback:
-        :return:
-        """
-        name = str(relation)
-
-        if isinstance(relation, BaseRelation):
-            name = name[:-1]
-
-        if name not in self._hooks:
-            return
-        self._hooks[name].discard(callback)
-
-    def _initialize_neural_module(self, dataset_builder: DatasetBuilder, settings: SettingsProxy, model):
+    def _initialize_neural_module(self, dataset_builder: DatasetBuilder, settings: SettingsProxy, model, torch: bool):
         self._dataset_builder = dataset_builder
         self._settings = settings
         self._neural_model = model
 
+        if torch:
+            try:
+                import torch
+            except:
+                raise Exception("torch is not installed in the environment")
+
+            from neuralogic.core.torch.neural_module import TorchNeuralModule
+
+            self._torch_module = TorchNeuralModule()
+
         optimizer = self._settings.optimizer.initialize()
         lr_decay = self._settings.optimizer.get_lr_decay()
 
@@ -266,23 +224,19 @@ class NeuralModule:
 
         self.reset_parameters()
 
-    def _run_hook(self, hook: str, value):
-        for callback in self._hooks[hook]:
-            callback(value)
-
     def _dataset_to_samples(self, dataset):
         if isinstance(dataset, Dataset):
             dataset = self.build_dataset(dataset)
             return dataset._samples, dataset._batch_size
 
+        if isinstance(dataset, GroundedDataset):
+            dataset = dataset.neuralize()
+            return dataset._samples, dataset._batch_size
+
         if isinstance(dataset, BuiltDataset):
             return dataset._samples, dataset._batch_size
         return dataset, 1
 
-    def _set_hooks(self):
-        if len(self._hooks) != 0:
-            self._strategy.setHooks(set(self._hooks.keys()), self._hook_handler)
-
     def _sync_template(self, state_dict: dict | None = None, weights=None):
         state_dict = self.state_dict() if state_dict is None else state_dict
         weights = self._parsed_template.getAllWeights() if weights is None else weights