Is mowl available for owl ontology of serializations other than .owl?

[20Bolin]

How are the adaptability of the methods in mowl for owl ontology in other serialization? I have some owl ontology serialized and saved in .rdf or .ttl. There are some issues while they are converted into .owl and thus the conversion might not be an ideal option. I wonder how well the embedding methods in mowl perform on these serializations. Or is it even possible to use mowl methods on them? An example is that when I tried to implement ELEmbedding on my owl ontology serialized in turtle, it raised an IndexError in the training. But the same code goes well on .owl serialization.

cwd = os.getcwd()
ds = CustomDataset(ontology_path="cbs.ttl")
dataset = ds
model_filepath=os.path.join(cwd, "cbs_embedding.pt")
model = OntoEmbedding(dataset,
                 #num_individuals=num_individuals,
                 embed_dim=30,
                 margin=0.05,
                 reg_norm=1,
                 learning_rate=0.001,
                 epochs=50,
                 batch_size=4096,
                 model_filepath=model_filepath,
                 device='cpu')
model.module.ind_embed = nn.Embedding(num_embeddings=len(dataset.classes), embedding_dim=30)
model.train()
print("Model file path:", model_filepath)

IndexError                                Traceback (most recent call last)
Cell In[16], line 13
      2 model = OntoEmbedding(dataset,
      3                  #num_individuals=num_individuals,
      4                  embed_dim=30,
   (...)
     10                  model_filepath=model_filepath,
     11                  device='cpu')
     12 model.module.ind_embed = nn.Embedding(num_embeddings=len(dataset.classes), embedding_dim=30)
---> 13 model.train()
     14 print("Model file path:", model_filepath)

Cell In[11], line 28, in OntoEmbedding.train(self, validate_every)
     25 if len(gci_dataset) == 0:
     26     continue
---> 28 loss += th.mean(self.module(gci_dataset[:], gci_name))
     29 if gci_name == "gci2":
     30     idxs_for_negs = np.random.choice(prots, size=len(gci_dataset), replace=True)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\modules\module.py:1532, in Module._wrapped_call_impl(self, *args, **kwargs)
   1530     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
   1531 else:
-> 1532     return self._call_impl(*args, **kwargs)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\modules\module.py:1541, in Module._call_impl(self, *args, **kwargs)
   1536 # If we don't have any hooks, we want to skip the rest of the logic in
   1537 # this function, and just call forward.
   1538 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1539         or _global_backward_pre_hooks or _global_backward_hooks
   1540         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1541     return forward_call(*args, **kwargs)
   1543 try:
   1544     result = None

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\mowl\nn\el\elmodule.py:179, in ELModule.forward(self, gci, gci_name, neg)
    176 def forward(self, gci, gci_name, neg=False):
    177     loss_fn = self.get_loss_function(gci_name)
--> 179     loss = loss_fn(gci, neg=neg)
    180     return loss

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\mowl\nn\el\elem\module.py:86, in ELEmModule.class_assertion_loss(self, data, neg)
     84 if self.ind_embed is None:
     85     raise ValueError("The number of individuals must be specified to use this loss function.")
---> 86 return L.class_assertion_loss(data, self.class_embed, self.class_rad, self.ind_embed, self.margin, neg=neg)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\mowl\nn\el\elem\losses.py:8, in class_assertion_loss(data, class_embed, class_rad, ind_embed, margin, neg)
      6 c = class_embed(data[:, 0])
      7 rc = th.abs(class_rad(data[:, 0]))
----> 8 i = ind_embed(data[:, 1])
     10 dist = th.linalg.norm(c - i, dim=1, keepdim=True) - rc
     11 loss = th.relu(dist - margin)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\modules\module.py:1532, in Module._wrapped_call_impl(self, *args, **kwargs)
   1530     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
   1531 else:
-> 1532     return self._call_impl(*args, **kwargs)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\modules\module.py:1541, in Module._call_impl(self, *args, **kwargs)
   1536 # If we don't have any hooks, we want to skip the rest of the logic in
   1537 # this function, and just call forward.
   1538 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1539         or _global_backward_pre_hooks or _global_backward_hooks
   1540         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1541     return forward_call(*args, **kwargs)
   1543 try:
   1544     result = None

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\modules\sparse.py:163, in Embedding.forward(self, input)
    162 def forward(self, input: Tensor) -> Tensor:
--> 163     return F.embedding(
    164         input, self.weight, self.padding_idx, self.max_norm,
    165         self.norm_type, self.scale_grad_by_freq, self.sparse)

File ~\Software\Anaconda\envs\mOWL\Lib\site-packages\torch\nn\functional.py:2264, in embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)
   2258     # Note [embedding_renorm set_grad_enabled]
   2259     # XXX: equivalent to
   2260     # with torch.no_grad():
   2261     #   torch.embedding_renorm_
   2262     # remove once script supports set_grad_enabled
   2263     _no_grad_embedding_renorm_(weight, input, max_norm, norm_type)
-> 2264 return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse)

IndexError: index out of range in self

[ferzcam]

Hi. We rely on the OWLAPI to load ontologies, so it should accept all those formats you mention. Specifically, in the error you show, the problem is not the ontology format but the problem arises because you call the class_assertion_loss function which computes scores for ABox axioms of the form C(a), can you make sure you ontology contains individuals and that you are passing the indices correctly?

[ferzcam]

Hi, I modified your training loop a bit to get more information. I print the number of individuals and the GCI where the error appears:

  def train(self, validate_every=1000):

        optimizer = th.optim.Adam(self.module.parameters(), lr=self.learning_rate)
        #best_loss = float('inf')
        
        prots = [self.class_index_dict[p] for p
                 in self.dataset.evaluation_classes[0].as_str]
        
        num_embeddings = len(self.dataset.classes)
        num_inds = len(self.dataset.individuals)
        print(f"Number of embeddings: {num_embeddings}")
        print(f"Number of individuals: {num_inds}")
        # Print the maximum index in the dataset
        max_index = max([gci_dataset[:, 1].max().item() for gci_dataset in self.training_datasets.values() if len(gci_dataset) > 0])
        print(f"Maximum index in the dataset: {max_index}")
        
        for epoch in trange(self.epochs):
            self.module.train()

            train_loss = 0
            loss = 0

            for gci_name, gci_dataset in self.training_datasets.items():
                print(f"Training on {gci_name} with {len(gci_dataset)} samples.")
                if len(gci_dataset) == 0:
                    continue

The output is the following:

Number of embeddings: 18
Number of individuals: 208
All indices are within the valid range.
Training on gci1 with 0 samples.
Training on gci2 with 0 samples.
Training on gci3 with 11 samples.
All indices are within the valid range.
Training on gci0_bot with 0 samples.
Training on gci1_bot with 0 samples.
Training on gci3_bot with 0 samples.
Training on class_assertion with 206 samples.

As you can see, the issue appears for axioms $C(a)$, where $a$ are individuals. There are 208 individuals, but after applying EL normalization, extra individuals are generated, which in total add up to 403. I would suggest to normalize the ontology beforehand so all the individuals can be capture by the ELEmbedding model.

[20Bolin]

Hi, I modified your training loop a bit to get more information. I print the number of individuals and the GCI where the error appears:

  def train(self, validate_every=1000):

        optimizer = th.optim.Adam(self.module.parameters(), lr=self.learning_rate)
        #best_loss = float('inf')
        
        prots = [self.class_index_dict[p] for p
                 in self.dataset.evaluation_classes[0].as_str]
        
        num_embeddings = len(self.dataset.classes)
        num_inds = len(self.dataset.individuals)
        print(f"Number of embeddings: {num_embeddings}")
        print(f"Number of individuals: {num_inds}")
        # Print the maximum index in the dataset
        max_index = max([gci_dataset[:, 1].max().item() for gci_dataset in self.training_datasets.values() if len(gci_dataset) > 0])
        print(f"Maximum index in the dataset: {max_index}")
        
        for epoch in trange(self.epochs):
            self.module.train()

            train_loss = 0
            loss = 0

            for gci_name, gci_dataset in self.training_datasets.items():
                print(f"Training on {gci_name} with {len(gci_dataset)} samples.")
                if len(gci_dataset) == 0:
                    continue

The output is the following:

Number of embeddings: 18
Number of individuals: 208
All indices are within the valid range.
Training on gci1 with 0 samples.
Training on gci2 with 0 samples.
Training on gci3 with 11 samples.
All indices are within the valid range.
Training on gci0_bot with 0 samples.
Training on gci1_bot with 0 samples.
Training on gci3_bot with 0 samples.
Training on class_assertion with 206 samples.

As you can see, the issue appears for axioms C ( a ) , where a are individuals. There are 208 individuals, but after applying EL normalization, extra individuals are generated, which in total add up to 403. I would suggest to normalize the ontology beforehand so all the individuals can be capture by the ELEmbedding model.

Hi, sorry that I forget to update you. I also managed to find that the minimum number of embeddings for this case is 403 and I tried to set the number of embeddings in the model as 404 or any number larger than 403, then the training works.

But I am still confused how 403 was generated because I checked the number of individuals, 208, and the number of classes, 18, which is the same as the number of embeddings, as well as the number of object properties, but still could not figure out how 403 was calculated. Now you explain clearly that some extras are added because of the EL normalization.

Is how the normalization algorithm calculates the extra individuals also in the code? Also, for "I would suggest to normalize the ontology beforehand so all the individuals can be capture by the ELEmbedding model.", could you explain more about how to do the normalization beforehand or do you have any useful materials for it?

Thank you in advance!

[20Bolin]

And my understanding is, if the ontology normalization is implemented beforehand then the extra individuals will not be generated and added, so the training will go smoothly without the index error. Is it correct?

[20Bolin]

OK I checked the normalize.py of mowl and other literature. Now I am trying on DeepOnto for the ontology normalization.

[ferzcam]

And my understanding is, if the ontology normalization is implemented beforehand then the extra individuals will not be generated and added, so the training will go smoothly without the index error. Is it correct?

Yes, well, the extra elements will be generated, but they will also be included in the embedding look up table, so you will not face the out of range error.