chebai/ChEBI25-3STAR-ILP

This dataset consists of 1,808 Inductive Logic Programming (ILP) problems based on the ChEBI25-3STAR dataset. Each problem is based on a class in ChEBI (v248) that has at least 25 molecule-annotated subclasses which are used as samples. The samples are divided into train, validation and test subsets by a global 80/10/10 split. This means that a sample always belongs to the same subset for each ILP problem.

In contrast to the ChEBI25-3STAR dataset, not all positive and negative samples are necessarily included in the ILP problems.

• For the training split, positive samples are chosen randomly up to a maximum of 200. Negative samples are chosen by distance to the true label via breadth first search. The search iterates until the maximum of 200 samples is reached or the minimum of 25 samples is reached and all samples at the current distance level are included.
• For the validation and test split, all positive samples and negative samples that are siblings to positive samples (i.e. that belong to a direct superclass of the true label) are included.

The code used to generate these problems can be found on GitHub.

Problem Structure

Each problem is structured as follows:

chebi_<id>/                        # one directory per ChEBI class
├── train/
│   ├── exs.pl                     # positive and negative examples
│   │                              #   pos(chebi_<id>(<mol_id>)).
│   │                              #   neg(chebi_<id>(<mol_id>)).
│   │
│   └── atoms/           # atom-based encoding of molecules
│       ├── bk.pl                  # background knowledge: all molecule facts
│       │                          #   has_atom(mol_id, atom_id).
│       │                          #   o(atom_id).  c(atom_id).  ...
│       │                          #   bSINGLE(a1, a2).  bDOUBLE(a1, a2).  ...
│       │                          #   has_1_hs(atom_id).  cip_code_R(atom_id). ...
│       │
│       ├── bias.pl                # Popper bias file without search space constraints
│       │                          #   head_pred(chebi_<id>, 1).
│       │                          #   body_pred(<predicate>, <arity>).  ...                             
│       │
│       ├── bias_max_vars=6_max_body=8_max_clauses=2.pl
│       │                          # Popper bias file with search space constraints
│       │                          #   max_vars(6). max_body(8). max_clauses(2).
│
├── validation/
│   ├── exs.pl                     # positive and negative examples
│   └── atoms/
│       └── bk.pl                  # BK for validation molecules (same format)
│
└── test/
│   ├── exs.pl                     # positive and negative examples
    └── atoms/
        └── bk.pl                  # BK for test molecules (same format)

Usage

The problems are designed for the ILP system Popper.

Here is a basic eample for training an ILP rule with Popper:

from popper.util import Settings, format_prog
from popper.loop import learn_solution

CHEBI_ID = "26410"
PREDICATE_SET = "atoms"
BIAS = "bias_max_vars=6_max_body=8_max_clauses=2"

base = f"chebi_{CHEBI_ID}/train"

settings = Settings(
    ex_file   = f"{base}/exs.pl",
    bk_file   = f"{base}/{PREDICATE_SET}/bk.pl",
    bias_file = f"{base}/{PREDICATE_SET}/{BIAS}.pl",
    noisy     = True,           # allow imperfect rules (noise tolerance)
    anytime_solver = "nuwls",   # MaxSAT solver used during search
    timeout   = 60,             # seconds
)

prog, score, stats = learn_solution(settings)

if prog:
    print(format_prog(prog))
else:
    print("No rule found within timeout.")