OntoLearner

https://ontolearner.readthedocs.io/
Admin
OntoLearner is a modular, open-source Python framework purpose-built for modern ontology learning...
Tokens:200,115
Snippets:2,733
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Verify OntoLearner Installation

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

After installation, use this Python snippet to print the installed OntoLearner version and confirm successful setup.

```python
import ontolearner

print(ontolearner.__version__)
```

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

### Install OntoLearner

Source: https://ontolearner.readthedocs.io/index.html

Install the OntoLearner package using pip. Python 3.10+ and PyTorch 2.4.0+ are recommended.

```bash
pip install -U ontolearner

```

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

### Install OntoLearner from Source

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

Install OntoLearner in editable mode from its source code after cloning the repository. This is ideal for development.

```bash
pip install -e .
```

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

### Install OntoLearner from GitHub

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

Install the latest development version of OntoLearner directly from the main branch on GitHub using pip.

```bash
pip install git+https://github.com/sciknoworg/OntoLearner.git
```

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

### Install OntoLearner from PyPI

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

Install the latest stable version of OntoLearner using pip from the Python Package Index.

```bash
pip install -U ontolearner
```

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

### Create and Activate Virtual Environment

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

Optional but recommended step to create and activate a Python virtual environment for installing OntoLearner from source. Use 'venv\Scripts\activate' on Windows.

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

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

### Install OntoLearner

Source: https://ontolearner.readthedocs.io/_sources/ontologizer/new_ontologies.rst.txt

Install or upgrade OntoLearner using pip. This command ensures you have the latest version for ontology management.

```bash
pip install -U OntoLearner
```

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

### Clone OntoLearner Repository

Source: https://ontolearner.readthedocs.io/_sources/installation.rst.txt

Clone the OntoLearner repository from GitHub to install from source.

```bash
git clone https://github.com/sciknoworg/OntoLearner.git
cd OntoLearner
```

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

### Initialize SKHNLPSequentialFTLearner

Source: https://ontolearner.readthedocs.io/_sources/learners/llms4ol_challenge/skhnlp_learner.rst.txt

Configure and initialize the BERT-based learner for supervised fine-tuning. This setup includes specifying the model name, prompt configuration, device, output directories, training parameters, and evaluation/saving strategies.

```python
from ontolearner import SKHNLPSequentialFTLearner

bert_learner = SKHNLPSequentialFTLearner(
    model_name="bert-large-uncased",
    n_prompts=2,
    random_state=1403,
    device="cpu",  # Note: CPU training for BERT-Large is slow.
    output_dir="./results/",
    num_train_epochs=1,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs/",
    logging_steps=50,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

# Load the base BERT model and prepare it for supervised taxonomy discovery
bert_learner.load(llm_id=bert_learner.model_name)
```

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

### Offline Augmentation Loading and Setup

Source: https://ontolearner.readthedocs.io/_sources/learners/retrieval.rst.txt

Loads previously generated augmentation data from a JSON file and sets up the LLMAugmentedRetriever and LLMAugmentedRetrieverLearner. Recommended for large experiments to avoid repeated LLM calls.

```python
# Step 1 — Load augmenter
from ontolearner.learner.retriever import LLMAugmenter
Augmenter = LLMAugmenter("augment.json")

# Step 2 — Attach it to the retriever
from ontolearner.learner.retriever import LLMAugmentedRetriever
from ontolearner.learner import LLMAugmentedRetrieverLearner

base_retriever = LLMAugmentedRetriever()
learner = LLMAugmentedRetrieverLearner(base_retriever=base_retriever)
learner.set_augmenter(augmenter)
learner.load(model_id="Qwen/Qwen3-Embedding-8B") # path to desired retriever model.
```

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

### Initialize and Run RAG Pipeline

Source: https://ontolearner.readthedocs.io/learners/rag.html

Demonstrates initializing a LearnerPipeline with specific retriever and LLM IDs for a RAG setup. The pipeline is then used to train, predict, and evaluate on provided data.

```python
from ontolearner import (
    LearnerPipeline,
    AutoLLMLearner,
    AutoRetrieverLearner,
    AutoRAGLearner,
    LabelMapper,
    StandardizedPrompting,
    AgrO,
    train_test_split,
)

ontology = AgrO()
ontology.load()  # Load entities, types, and structured term annotations from the ontology
ontological_data = ontology.extract()
# Extract term-typing instances and split into train and test sets
train_data, test_data = train_test_split(
    ontological_data,
    test_size=0.2,          # Use 20% of the data for evaluation
    random_state=42         # Ensure reproducibility of the data split
)
# Initialize a multi-component learning pipeline (retriever + LLM)
# This configuration enables a Retrieval-Augmented Generation (RAG) setup
pipeline = LearnerPipeline(
    retriever_id='sentence-transformers/all-MiniLM-L6-v2',      # Dense retriever model for nearest neighbor search
    llm_id='Qwen/Qwen2.5-0.5B-Instruct',                        # Lightweight instruction-tuned LLM for reasoning
    hf_token='...',                                             # Hugging Face token for accessing gated models
    batch_size=32,                                              # Batch size for training/prediction if supported
    top_k=5                                                     # Number of top retrievals to include in RAG prompting
)
# Run the pipeline: training, prediction, and evaluation in one call
outputs = pipeline(
    train_data=train_data,
    test_data=test_data,
    evaluate=True,              # Compute metrics like precision, recall, and F1
    task='term-typing'          # Specifies the task
)
# Print final evaluation metrics
print("Metrics:", outputs['metrics'])
# Print the total time taken for the full pipeline execution
print("Elapsed time:", outputs['elapsed_time'])
# Print all outputs (including predictions)
print(outputs)
```

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

### Configure a RAG-based Learner Pipeline

Source: https://ontolearner.readthedocs.io/_sources/quickstart.rst.txt

Sets up a LearnerPipeline for RAG tasks, specifying both a retriever and an LLM. Includes parameters for Hugging Face token, batch size, and top_k for retrieved examples.

```python
from ontolearner import LearnerPipeline

pipeline = LearnerPipeline(
    retriever_id='sentence-transformers/all-MiniLM-L6-v2',
    llm_id='Qwen/Qwen2.5-0.5B-Instruct',
    hf_token='<YOUR_HF_TOKEN>',
    batch_size=16,
    top_k=3
)
```

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

### Pipeline Usage with RAG Learner

Source: https://ontolearner.readthedocs.io/_sources/learners/rag.rst.txt

Demonstrates using the LearnerPipeline to automatically configure and run a RAG setup. This includes data preparation, pipeline initialization with RAG components, and executing the pipeline for training, prediction, and evaluation.

```python
from ontolearner import (
    LearnerPipeline,
    AutoLLMLearner,
    AutoRetrieverLearner,
    AutoRAGLearner,
    LabelMapper,
    StandardizedPrompting,
    AgrO,
    train_test_split,
)

ontology = AgrO()
ontology.load()  # Load entities, types, and structured term annotations from the ontology
ontological_data = ontology.extract()
# Extract term-typing instances and split into train and test sets
train_data, test_data = train_test_split(
    ontological_data,
    test_size=0.2,          # Use 20% of the data for evaluation
    random_state=42         # Ensure reproducibility of the data split
)
# Initialize a multi-component learning pipeline (retriever + LLM)
# This configuration enables a Retrieval-Augmented Generation (RAG) setup
pipeline = LearnerPipeline(
    retriever_id='sentence-transformers/all-MiniLM-L6-v2',      # Dense retriever model for nearest neighbor search
    llm_id='Qwen2.5-0.5B-Instruct',                        # Lightweight instruction-tuned LLM for reasoning
    hf_token='...',                                             # Hugging Face token for accessing gated models
    batch_size=32,                                              # Batch size for training/prediction if supported
    top_k=5                                                     # Number of top retrievals to include in RAG prompting
)
# Run the pipeline: training, prediction, and evaluation in one call
outputs = pipeline(
    train_data=train_data,
    test_data=test_data,
    evaluate=True,              # Compute metrics like precision, recall, and F1
    task='term-typing'          # Specifies the task
)
# Print final evaluation metrics
print("Metrics:", outputs['metrics'])
# Print the total time taken for the full pipeline execution
print("Elapsed time:", outputs['elapsed_time'])
# Print all outputs (including predictions)
print(outputs)
```

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

### OntoCAPE Ontology Usage Example

Source: https://ontolearner.readthedocs.io/benchmarking/materials_science_and_engineering/ontocape.html

Demonstrates how to initialize OntoCAPE, load an ontology file, extract data, and access specific relations like term types and taxonomies. This is useful for annotating process engineering projects.

```python
from ontolearner.ontology import OntoCAPE

# Initialize and load ontology
ontology = OntoCAPE()
ontology.load("path/to/ontology.owl")

# Extract datasets
data = ontology.extract()

# Access specific relations
term_types = data.term_typings
taxonomic_relations = data.type_taxonomies
non_taxonomic_relations = data.type_non_taxonomic_relations

```

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

### LearnerPipeline Initialization

Source: https://ontolearner.readthedocs.io/package_reference/pipeline.html

Initializes the LearnerPipeline for ontology learning. It supports various configurations including retriever-only, LLM-only, and RAG modes, allowing for flexible setup through pre-initialized components or model IDs.

```APIDOC
## LearnerPipeline

### Description
Initializes the pipeline for ontology learning tasks. Supports retriever-only, LLM-only, or Retrieval-Augmented Generation (RAG) learners. RAG can be configured by passing both retriever and LLM components (or their model IDs), or by passing a pre-built RAG learner.

### Method
__init__

### Parameters
* **retriever** (~typing.Any | None) - Pre-initialized retriever learner.
* **llm** (~typing.Any | None) - Pre-initialized LLM learner.
* **rag** (~typing.Any | None) - Pre-initialized `AutoRAGLearner` (or compatible) instance.
* **retriever_id** (str | None) - Retriever model ID used when loading retriever components.
* **llm_id** (str | None) - LLM model ID used when loading LLM components.
* **prompting** (~ontolearner.base.learner.AutoPrompt | None) - Prompting strategy for AutoLLMLearner initialization. Defaults to `<class 'ontolearner.learner.prompt.StandardizedPrompting'>`.
* **label_mapper** (~ontolearner.learner.label_mapper.LabelMapper | None) - Label mapper for AutoLLMLearner initialization. Defaults to an instance of `LabelMapper`.
* **hf_token** (str | None) - Hugging Face token (for gated model access).
* **ontologizer_data** (bool) - If True, uses Ontologizer-style datasets by default. Defaults to True.
* **top_k** (int) - Number of top examples retrieved for retriever/RAG workflows. Defaults to 5.
* **batch_size** (int) - Batch size used by learner backends where applicable. Defaults to 10.
* **device** (str) - Target device for model execution (e.g., ‘cpu’, ‘cuda’). Defaults to 'cpu'.
* **max_new_tokens** (int) - Max generated tokens for LLM generation. Defaults to 10.
```

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

### AutoRetriever.retrieve

Source: https://ontolearner.readthedocs.io/package_reference/learner.html

Retrieve the top-k most similar examples for each query in a list of queries.

```APIDOC
## AutoRetriever.retrieve

### Description
Retrieve the top-k most similar examples for each query in a list of queries.

### Parameters
#### Path Parameters
None

#### Query Parameters
- **query** (List[str]) - Required - List of query examples.
- **top_k** (int) - Optional - Number of most similar examples to retrieve per query. Defaults to 5.
- **batch_size** (int) - Optional - Batch size for retrieval. Defaults to -1 (automatic).

#### Request Body
None

### Method
Not applicable (Python method)

### Endpoint
Not applicable (Python method)

### Request Example
None

### Response
#### Success Response
- **List[List[str]]**: A list of lists, where each sublist contains the top-k most similar examples for the corresponding query.

#### Response Example
None
```

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

### Initialize LLMAugmentedRetriever and Learner

Source: https://ontolearner.readthedocs.io/learners/retrieval.html

Initializes the LLMAugmentedRetriever and the LLMAugmentedRetrieverLearner, setting up the base retriever and loading a model.

```python
from ontolearner.learner.retriever import LLMAugmentedRetriever
from ontolearner.learner import LLMAugmentedRetrieverLearner

base_retriever = LLMAugmentedRetriever()
learner = LLMAugmentedRetrieverLearner(base_retriever=base_retriever)
learner.set_augmenter(augmenter)
learner.load(model_id="Qwen/Qwen3-Embedding-8B")
```

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

### AutoRetriever.retrieve

Source: https://ontolearner.readthedocs.io/package_reference/learner.html

Retrieves the top-k most similar examples for a given query. This method is intended to be implemented by concrete subclasses.

```APIDOC
## AutoRetriever.retrieve

### Description
Retrieve the top-k most similar examples for each query in a list of queries.

### Method
Not specified (abstract method)

### Endpoint
None

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **query** (List[str]) - Required - List of query examples.
- **top_k** (int) - Optional - Default: 5 - Number of most similar examples to retrieve per query.
- **batch_size** (int) - Optional - Default: -1 - Batch size for processing queries.

### Returns
- List[List[str]] - A list of lists, where each sublist contains the top-k most similar examples for the corresponding query.

### Raises
- **NotImplementedError** - If not implemented by concrete class.
```

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

### Initialize SBUNLPFewShotLearner for Taxonomy Discovery

Source: https://ontolearner.readthedocs.io/learners/llms4ol_challenge/sbunlp_learner.html

Configure the SBUNLPFewShotLearner with a Qwen model for in-context learning using an N x M batch prompting scheme. Set model parameters, batching strategy, and output directory.

```python
from ontolearner import SBUNLPFewShotLearner

llm_learner = SBUNLPFewShotLearner(
    # Model / decoding
    model_name="Qwen/Qwen2.5-0.5B-Instruct",
    try_4bit=True,              # use 4-bit if bitsandbytes + CUDA are available
    max_new_tokens=140,         # limit the length of the model's response (JSON output)
    max_input_tokens=1500,      # limit the total prompt length (context window)
    temperature=0.0,            # set to 0.0 for deterministic output
    top_p=1.0,

    # Grid settings (N × M prompts)
    n_train_chunks=7,           # N: split training examples into 7 chunks
    m_test_chunks=7,            # M: split test terms into 7 chunks (total 49 prompts)

    # Run controls
    limit_prompts=None,         # None runs all N × M prompts; set an int for a restricted run
    output_dir="./outputs/taskC_batches",  # dump per-prompt JSON results for debugging
)
```

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

### Load Ontology and Split Data

Source: https://ontolearner.readthedocs.io/learners/llm.html

Imports necessary components, loads ontology data, and performs train-test splits. Ensure AgrO is installed and accessible.

```python
from ontolearner import AutoLLMLearner, AgrO, train_test_split, LabelMapper, StandardizedPrompting, evaluation_report

ontology = AgrO()

ontology.load()

ontological_data = ontology.extract()

train_data, test_data = train_test_split(ontological_data, test_size=0.2, random_state=42)

```

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

### Initialize SBUNLPFewShotLearner

Source: https://ontolearner.readthedocs.io/_sources/learners/llms4ol_challenge/sbunlp_learner.rst.txt

Configure the SBUNLP few-shot learner for the Text2Onto task. This learner uses an LLM to produce predictions from synthetic Text2Onto-style samples. Specify the LLM model ID, device, maximum new tokens, and output directory.

```python
from ontolearner.learner.text2onto import SBUNLPFewShotLearner

text2onto_learner = SBUNLPFewShotLearner(
    llm_model_id="Qwen/Qwen2.5-0.5B-Instruct",
    device="cpu",            # set "cuda" if available
    max_new_tokens=256,
    output_dir="./results/",
)
```

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

### AutoRetriever.index

Source: https://ontolearner.readthedocs.io/package_reference/learner.html

Index the provided inputs for efficient retrieval. This method processes and indexes the training examples to enable fast similarity search during retrieval operations.

```APIDOC
## AutoRetriever.index

### Description
Index the provided inputs for efficient retrieval. This method processes and indexes the training examples to enable fast similarity search during retrieval operations.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **inputs** (List[str]) - Required - List of examples to index. Format depends on the specific retrieval implementation and task requirements.

### Method
Not applicable (Python method)

### Endpoint
Not applicable (Python method)

### Request Example
None

### Response
#### Success Response
None

#### Response Example
None

### Raises
- **NotImplementedError**: If not implemented by concrete class.
```

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

### Initialize SBUNLP Few-Shot Learner

Source: https://ontolearner.readthedocs.io/_sources/learners/llms4ol_challenge/sbunlp_learner.rst.txt

Configures and initializes the SBUNLP Few-Shot Learner with a Qwen model for taxonomy discovery. Adjust model parameters and batch prompting settings as needed.

```python
task = "taxonomy-discovery"

from ontolearner import SBUNLPFewShotLearner

llm_learner = SBUNLPFewShotLearner(
    # Model / decoding
    model_name="Qwen/Qwen2.5-0.5B-Instruct",
    try_4bit=True,              # use 4-bit if bitsandbytes + CUDA are available
    max_new_tokens=140,         # limit the length of the model's response (JSON output)
    max_input_tokens=1500,      # limit the total prompt length (context window)
    temperature=0.0,            # set to 0.0 for deterministic output
    top_p=1.0,

    # Grid settings (N × M prompts)
    n_train_chunks=7,           # N: split training examples into 7 chunks
    m_test_chunks=7,            # M: split test terms into 7 chunks (total 49 prompts)

    # Run controls
    limit_prompts=None,         # None runs all N × M prompts; set an int for a restricted run
    output_dir="./outputs/taskC_batches",  # dump per-prompt JSON results for debugging
)

# Load the underlying LLM and prepare it for few-shot taxonomy discovery
llm_learner.load(llm_id=llm_learner.model_name)
```

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

### Initialize Learner Pipeline

Source: https://ontolearner.readthedocs.io/_sources/learners/llm.rst.txt

Sets up the LearnerPipeline for LLM-only mode by specifying the LLM ID and Hugging Face token. The batch size can be adjusted for performance.

```python
# Import the main components from the OntoLearner library
from ontolearner import LearnerPipeline, AgrO, train_test_split

# Load the AgrO ontology, which contains agricultural concepts and relationships
ontology = AgrO()
ontology.load()  # Parse and initialize internal ontology structures, including term-type pairs

# Extract annotated examples (terms and their types), and split into train/test sets
train_data, test_data = train_test_split(
    ontology.extract(),     # Extract raw (term, types) instances from the ontology
    test_size=0.2,          # 20% of the data is reserved for evaluation
    random_state=42         # Ensure reproducibility by setting a fixed seed
)

# Set up the learner pipeline using a lightweight instruction-tuned LLM
pipeline = LearnerPipeline(
    llm_id='Qwen/Qwen2.5-0.5B-Instruct',   # LLM-only mode
    hf_token='...',                        # Hugging Face access token for loading gated models
    batch_size=32                          # Batch size for parallel inference (if applicable)
)
```

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

### Load Ontological Data and Split

Source: https://ontolearner.readthedocs.io/learners/retrieval.html

Imports necessary components, loads the AgrO ontology, extracts data, and performs a train-test split. Ensure ontolearner package is installed.

```python
from ontolearner import AutoRetrieverLearner, AgrO, train_test_split, evaluation_report

ontology = AgrO()

ontology.load()

ontological_data = ontology.extract()

train_data, test_data = train_test_split(ontological_data, test_size=0.2, random_state=42)

```

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

### Initialize and Run Learner Pipeline in Retriever-Only Mode

Source: https://ontolearner.readthedocs.io/_sources/learners/retrieval.rst.txt

Demonstrates setting up a LearnerPipeline for retrieval-only tasks using a specified Hugging Face model. It shows how to run the pipeline on training and test data and access evaluation metrics and elapsed time.

```python
pipeline = LearnerPipeline(
    retriever_id='sentence-transformers/all-MiniLM-L6-v2',  # Hugging Face model ID for retrieval
    batch_size=10,       # Number of samples to process per batch (if batching is enabled internally)
    top_k=5              # Retrieve top-5 most relevant support instance per query
)

# Run the pipeline on the training and test data
# The pipeline performs: fit() → predict() → evaluate() in sequence
outputs = pipeline(
    train_data=train_data,
    test_data=test_data,
    evaluate=True,           # If True, computes precision, recall, and F1-score
    task='non-taxonomic-re'  # Specifies that we are doing non-taxonomic relation prediction
)

# Print the evaluation metrics (precision, recall, F1)
print("Metrics:", outputs['metrics'])

# Print the total elapsed time for training and evaluation
print("Elapsed time:", outputs['elapsed_time'])

# Print the full output dictionary (includes predictions)
print(outputs)
```

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

### Load Wine Ontology Programmatically

Source: https://ontolearner.readthedocs.io/_sources/ontologizer/ontology_modularization.rst.txt

Loads the Wine ontology, automatically downloading it from Hugging Face and preparing datasets. Use this to quickly start ontology-based learning tasks.

```python
from ontolearner import Wine

ontology = Wine()

ontology.load()  # Automatically downloads and prepares ontology

data = ontology.extract()  # Returns learning tasks data
```

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

### Initialize and Load LLM Learner

Source: https://ontolearner.readthedocs.io/_sources/learners/llm.rst.txt

Sets up the AutoLLMLearner with specified prompting and label mapping strategies, then loads the desired LLM model. Ensure the model ID is correct and accessible.

```python
llm_learner = AutoLLMLearner(
    prompting=StandardizedPrompting,
    label_mapper=LabelMapper(),
    token=token
)
llm_learner.load(model_id='Qwen/Qwen2.5-0.5B-Instruct')
```

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

### Import and Load FoodOn Ontology

Source: https://ontolearner.readthedocs.io/_sources/benchmarking/agriculture/foodon.rst.txt

Use this Python code to import the FoodOn ontology programmatically. Ensure you have the 'ontolearner' library installed and provide the correct path to the ontology file.

```python
from ontolearner.ontology import FoodOn

ontology = FoodOn()
ontology.load("path/to/FoodOn-ontology.owl")

# Extract datasets
data = ontology.extract()

# Access specific relations
term_types = data.term_typings
taxonomic_relations = data.type_taxonomies
non_taxonomic_relations = data.type_non_taxonomic_relations
```

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

### Pipeline Usage with Retriever-Only Mode

Source: https://ontolearner.readthedocs.io/_sources/learners/retrieval.rst.txt

Demonstrates using the LearnerPipeline with a retriever-only mode by providing only the retriever_id. This example loads the AgrO ontology, extracts and splits data, and initializes the pipeline.

```python
# Import core components from the OntoLearner library
from ontolearner import LearnerPipeline, AgrO, train_test_split

# Load the AgrO ontology, which includes structured agricultural knowledge
ontology = AgrO()
ontology.load()  # Load ontology data (e.g., entities, relations, metadata)

# Extract relation instances from the ontology and split them into training and test sets
train_data, test_data = train_test_split(
    ontology.extract(),      # Extract annotated (head, tail, relation) triples
    test_size=0.2,           # 20% for evaluation
    random_state=42          # Ensures reproducible splits
)

# Initialize the learning pipeline using a dense retriever
```

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

### Using Qwen3 Instruct LLM in OntoLearner

Source: https://ontolearner.readthedocs.io/_sources/learners/llm.rst.txt

This snippet demonstrates the integration of the Qwen3 Instruct LLM. It uses the `QwenInstructLLM` class and applies a chat template similar to the thinking model, with specific parameters for generation and padding.

```python
class QwenInstructLLM(AutoLLM):

    def generate(self, inputs: List[str], max_new_tokens: int = 50) -> List[str]:
        messages = [[{"role": "user", "content": prompt + " Please show your final response with 'answer': 'label'."}]
                    for prompt in inputs]

        texts = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

        encoded_inputs = self.tokenizer(texts, return_tensors="pt", padding="max_length", truncation=True,
                                        max_length=256).to(self.model.device)

        generated_ids = self.model.generate(**encoded_inputs,
                                            max_new_tokens=max_new_tokens,
                                            use_cache=False,
                                            pad_token_id=self.tokenizer.pad_token_id,
                                            eos_token_id=self.tokenizer.eos_token_id)
        decoded_outputs = []
        for i in range(len(generated_ids)):
            prompt_len = encoded_inputs.attention_mask[i].sum().item()

```

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

### Load GeoNames Ontology for SFT

Source: https://ontolearner.readthedocs.io/_sources/learners/llms4ol_challenge/skhnlp_learner.rst.txt

Loads the GeoNames ontology and splits the taxonomic relationships into train and test sets, similar to the zero-shot setup. This prepares the data for supervised fine-tuning.

```python
from ontolearner import GeoNames, train_test_split

ontology = GeoNames()
ontology.load()
data = ontology.extract()
```

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

### Initialize SBU-NLP Zero-Shot Learner

Source: https://ontolearner.readthedocs.io/_sources/learners/llms4ol_challenge/sbunlp_learner.rst.txt

Initializes the SBUNLPZSLearner for zero-shot term typing using a Qwen model. Configuration includes model ID, decoding parameters like max_new_tokens and temperature. The learner's fit phase infers the type label inventory without fine-tuning the LLM.

```python
from ontolearner import SBUNLPZSLearner

llm_learner = SBUNLPZSLearner(
    # Model / decoding
    model_id="Qwen/Qwen2.5-0.5B-Instruct",
    max_new_tokens=64,  # sufficient length for JSON list of types
    temperature=0.0,    # deterministic (greedy) output
    # token=None,       # assuming public model access
)

# Load the underlying LLM and prepare it for zero-shot term typing
llm_learner.load(llm_id=llm_learner.model_id)
```

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

### Initialize SBU-NLP Zero-Shot Learner for Term Typing

Source: https://ontolearner.readthedocs.io/learners/llms4ol_challenge/sbunlp_learner.html

Initializes the SBU-NLP Zero-Shot learner with a Qwen model for term typing. The learner's fit phase infers the type label inventory without fine-tuning the model.

```python
from ontolearner import SBUNLPZSLearner

llm_learner = SBUNLPZSLearner(
    # Model / decoding
    model_id="Qwen/Qwen2.5-0.5B-Instruct",
    max_new_tokens=64,  # sufficient length for JSON list of types
    temperature=0.0,    # deterministic (greedy) output
    # token=None,       # assuming public model access
)

# Load the underlying LLM and prepare it for zero-shot term typing
llm_learner.load(llm_id=llm_learner.model_id)

```

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

### Configure Learner Pipeline with Prebuilt RAG Object

Source: https://ontolearner.readthedocs.io/_sources/quickstart.rst.txt

Demonstrates passing a pre-configured AutoRAGLearner object to the LearnerPipeline. This allows for custom RAG setups using separate retriever and LLM configurations.

```python
from ontolearner import (
    LearnerPipeline,
    AutoLLMLearner,
    AutoRetrieverLearner,
    AutoRAGLearner,
    LabelMapper,
    StandardizedPrompting,
)

retriever = AutoRetrieverLearner(top_k=3)
llm = AutoLLMLearner(
    prompting=StandardizedPrompting,
    label_mapper=LabelMapper(),
    token='<YOUR_HF_TOKEN>'
)
rag = AutoRAGLearner(retriever=retriever, llm=llm)

pipeline = LearnerPipeline(
    rag=rag,
    retriever_id='sentence-transformers/all-MiniLM-L6-v2',
    llm_id='Qwen/Qwen2.5-0.5B-Instruct'
)
```

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

### Load System Capabilities Ontology

Source: https://ontolearner.readthedocs.io/_sources/benchmarking/materials_science_and_engineering/systemcapabilities.rst.txt

This Python snippet demonstrates how to load the SystemCapabilities ontology programmatically using the ontolearner library. It shows how to initialize the ontology, load an OWL file, and extract data including term types, taxonomic relations, and non-taxonomic relations.

```python
from ontolearner.ontology import SystemCapabilities

ontology = SystemCapabilities()
ontology.load("path/to/SystemCapabilities-ontology.owl")

# Extract datasets
data = ontology.extract()

# Access specific relations
term_types = data.term_typings
taxonomic_relations = data.type_taxonomies
non_taxonomic_relations = data.type_non_taxonomic_relations
```

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

### Compute Ontology Complexity Score

Source: https://ontolearner.readthedocs.io/package_reference/tools.html

Calculates a normalized complexity score for an ontology by combining topology and dataset metrics. Use this to get a single, interpretable score representing overall ontology complexity.

```python
Analyzer._compute_complexity_score(topology_metrics, dataset_metrics, a=0.4, b=6.0, eps=1e-12)
```

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

### Initialize and Load AgrO Ontology

Source: https://ontolearner.readthedocs.io/_sources/index.rst.txt

Initialize an Ontologizer from OntoLearner and load the Agronomy Ontology (AgrO) automatically from Hugging Face.

```python
from ontolearner import AgrO

# 1. Initialize an ontologizer from OntoLearner
ontology = AgrO()

# 2. Load the ontology automatically from Hugging Face
ontology.load()

# 3. Extract the learning task dataset
data = ontology.extract()

print(ontology)
# outputs:
# ontology_id: AgrO
# ontology_full_name: Agronomy Ontology (AgrO)
# domain: Agriculture
# category: Agronomy
# version: 1.0
# last_updated: 2022-11-02
# creator: The Crop Ontology Consortium
# license: Creative Commons 4.0
# format: RDF
# download_url: https://agroportal.lirmm.fr/ontologies/AGRO?p=summary
```

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

### Load and Extract OBI Ontology Programmatically

Source: https://ontolearner.readthedocs.io/_sources/benchmarking/medicine/obi.rst.txt

Use this Python code to load the OBI ontology from a local file and extract its data. Ensure the 'ontolearner' library is installed and the ontology file path is correct.

```python
from ontolearner.ontology import OBI

ontology = OBI()
ontology.load("path/to/OBI-ontology.owl")

# Extract datasets
data = ontology.extract()

# Access specific relations
term_types = data.term_typings
taxonomic_relations = data.type_taxonomies
non_taxonomic_relations = data.type_non_taxonomic_relations
```

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

### Initialize RAG Learner Components

Source: https://ontolearner.readthedocs.io/_sources/learners/rag.rst.txt

Initializes the LLM learner with specific prompting and label mapping strategies, and the retriever learner to find top-k relevant examples. Requires a Hugging Face API token.

```python
task = 'non-taxonomic-re'

# Provide your huggingface token for LLM access
token = '...'

# Initialize the LLM learner with prompting and label mapping strategies
llm_learner = AutoLLMLearner(
    prompting=StandardizedPrompting,  # Use a pre-defined prompt format
    label_mapper=LabelMapper(),       # Convert between label formats and natural language
    token=token                       # API token to access the LLM
)

# Initialize the retriever to find top-k relevant facts or examples
retriever_learner = AutoRetrieverLearner(top_k=2)  # Use top 2 retrieved candidates

# Create a RAG (Retrieval-Augmented Generation) pipeline by combining LLM and retriever
rag_learner = AutoRAGLearner(
    llm=llm_learner,
    retriever=retriever_learner
)

# Load the retriever and LLM models by their names or IDs
rag_learner.load(
```

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

### Import and Load PreMOn Ontology

Source: https://ontolearner.readthedocs.io/benchmarking/scholarly_knowledge/premon.html

This snippet shows how to import the PreMOn class, instantiate it, and load an ontology file programmatically. It also demonstrates how to extract data and access specific relations like term types and taxonomic relations.

```python
from ontolearner.ontology import PreMOn

ontology = PreMOn()
ontology.load("path/to/PreMOn-ontology.owl")

# Extract datasets
data = ontology.extract()

# Access specific relations
term_types = data.term_typings
taxonomic_relations = data.type_taxonomies
non_taxonomic_relations = data.type_non_taxonomic_relations

```
Tokens:
Raw