Merge branch 'dev' into fix/ensemble-compatibility

# Conflicts:
#	setup.py

Author: sfluegel05

.github/workflows/black.yml

@@ -0,0 +1,26 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'  # or any version your project uses
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install black==25.1.0 ruff==0.12.2
+
+      - name: Run Black
+        run: black --check .
+
+      - name: Run Ruff (no formatting)
+        run: ruff check . --no-fix

.github/workflows/lint.yml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/psf/black
-    rev: "24.2.0"
+    rev: "25.1.0"
     hooks:
     -   id: black
     -   id: black-jupyter # for formatting jupyter-notebook
@@ -23,3 +23,9 @@ repos:
     -   id: check-yaml
     -   id: end-of-file-fixer
     -   id: trailing-whitespace
+
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.2
+    hooks:
+    -   id: ruff
+        args: [--fix]

.pre-commit-config.yaml

@@ -5,7 +5,12 @@ The library emphasizes the incorporation of the semantic qualities of the ontolo
 
 ## Installation
 
-To install ChEBai, follow these steps:
+You can install ChEBai via pip:
+```
+pip install chebai
+```
+
+Alternatively, you can get the latest development version directly from GitHub:
 
 1. Clone the repository:
 ```
@@ -16,8 +21,26 @@ git clone https://github.com/ChEB-AI/python-chebai.git
 
 ```
 cd python-chebai
-pip install .
+pip install -e .
+```
+
+Some packages are not installed by default:
+```
+pip install chebai[dev]
+```
+installs additional packages useful to people who want to contribute to the library.
+```
+pip install chebai[plot]
+```
+installs additional packages useful for plotting and visualisation.
+```
+pip install chebai[wandb]
+```
+installs the [Weights & Biases](https://wandb.ai) integration for automated logging of training runs.
+```
+pip install chebai[all]
 ```
+installs all optional dependencies.
 
 ## Usage
 

README.md

@@ -80,7 +80,7 @@ def write_on_epoch_end(
             else:
                 labels = [None for _ in idents]
             output = torch.sigmoid(p["output"]["logits"]).tolist()
-            for i, l, o in zip(idents, labels, output):
+            for i, l, o in zip(idents, labels, output):  # noqa: E741
                 pred_list.append(dict(ident=i, labels=l, predictions=o))
         with open(os.path.join(self.output_dir, self.target_file), "wt") as fout:
             json.dump(pred_list, fout)

chebai/callbacks.py

@@ -68,7 +68,7 @@ def __resolve_ckpt_dir(self, trainer: Trainer) -> _PATH:
         Returns:
             _PATH: The resolved checkpoint directory path.
         """
-        rank_zero_info(f"Resolving checkpoint dir (custom)")
+        rank_zero_info("Resolving checkpoint dir (custom)")
         if self.dirpath is not None:
             # short circuit if dirpath was passed to ModelCheckpoint
             return self.dirpath

chebai/callbacks/model_checkpoint.py

@@ -91,7 +91,7 @@ def cli():
     """
     Main function to instantiate and run the ChebaiCLI.
     """
-    r = ChebaiCLI(
+    ChebaiCLI(
         save_config_kwargs={"config_filename": "lightning_config.yaml"},
         parser_kwargs={"parser_mode": "omegaconf"},
     )

chebai/cli.py

@@ -1,7 +1,6 @@
 import os
 from typing import Optional
 
-import pandas as pd
 import torch
 
 from chebai.preprocessing.datasets.base import XYBaseDataModule

chebai/loss/bce_weighted.py

@@ -229,7 +229,7 @@ def forward(self, input: torch.Tensor, target: torch.Tensor, **kwargs) -> tuple:
         return total_loss.mean(), loss_components
 
     def _calculate_implication_loss(
-        self, l: torch.Tensor, r: torch.Tensor
+        self, l_: torch.Tensor, r: torch.Tensor
     ) -> torch.Tensor:
         """
         Calculate implication loss based on T-norm and other parameters.
@@ -241,17 +241,17 @@ def _calculate_implication_loss(
         Returns:
             torch.Tensor: Calculated implication loss.
         """
-        assert not l.isnan().any(), (
-            f"l contains NaN values - l.shape: {l.shape}, l.isnan().sum(): {l.isnan().sum()}, "
-            f"l: {l}"
+        assert not l_.isnan().any(), (
+            f"l contains NaN values - l.shape: {l_.shape}, l.isnan().sum(): {l_.isnan().sum()}, "
+            f"l: {l_}"
         )
         assert not r.isnan().any(), (
             f"r contains NaN values - r.shape: {r.shape}, r.isnan().sum(): {r.isnan().sum()}, "
             f"r: {r}"
         )
         if self.pos_scalar != 1:
-            l = (
-                torch.pow(l + self.eps, 1 / self.pos_scalar)
+            l_ = (
+                torch.pow(l_ + self.eps, 1 / self.pos_scalar)
                 - math.pow(self.eps, 1 / self.pos_scalar)
             ) / (
                 math.pow(1 + self.eps, 1 / self.pos_scalar)
@@ -269,21 +269,21 @@ def _calculate_implication_loss(
         # for each implication I, calculate 1 - I(l, 1-one_min_r)
         # for S-implications, this is equivalent to the t-norm
         if self.fuzzy_implication in ["reichenbach", "rc"]:
-            individual_loss = l * one_min_r
+            individual_loss = l_ * one_min_r
         # xu19 (from Xu et al., 2019: Semantic loss) is not a fuzzy implication, but behaves similar to the Reichenbach
         # implication
         elif self.fuzzy_implication == "xu19":
-            individual_loss = -torch.log(1 - l * one_min_r)
+            individual_loss = -torch.log(1 - l_ * one_min_r)
         elif self.fuzzy_implication in ["lukasiewicz", "lk"]:
-            individual_loss = torch.relu(l + one_min_r - 1)
+            individual_loss = torch.relu(l_ + one_min_r - 1)
         elif self.fuzzy_implication in ["kleene_dienes", "kd"]:
-            individual_loss = torch.min(l, 1 - r)
+            individual_loss = torch.min(l_, 1 - r)
         elif self.fuzzy_implication in ["goedel", "g"]:
-            individual_loss = torch.where(l <= r, 0, one_min_r)
+            individual_loss = torch.where(l_ <= r, 0, one_min_r)
         elif self.fuzzy_implication in ["reverse-goedel", "rg"]:
-            individual_loss = torch.where(l <= r, 0, l)
+            individual_loss = torch.where(l_ <= r, 0, l_)
         elif self.fuzzy_implication in ["binary", "b"]:
-            individual_loss = torch.where(l <= r, 0, 1).to(dtype=l.dtype)
+            individual_loss = torch.where(l_ <= r, 0, 1).to(dtype=l_.dtype)
         else:
             raise NotImplementedError(
                 f"Unknown fuzzy implication {self.fuzzy_implication}"
@@ -453,8 +453,8 @@ def _build_implication_filter(label_names: List, hierarchy: dict) -> torch.Tenso
 
 def _build_dense_filter(sparse_filter: torch.Tensor, n_labels: int) -> torch.Tensor:
     res = torch.zeros((n_labels, n_labels), dtype=torch.bool)
-    for l, r in sparse_filter:
-        res[l, r] = True
+    for l_, r in sparse_filter:
+        res[l_, r] = True
     return res
 
 
@@ -511,8 +511,8 @@ def _build_disjointness_filter(
     random_labels = torch.randint(0, 2, (10, 997))
     for agg in ["sum", "max", "mean", "log-mean"]:
         loss.violations_per_cls_aggregator = agg
-        l = loss(random_preds, random_labels)
-        print(f"Loss with {agg} aggregation for random input:", l)
+        l_ = loss(random_preds, random_labels)
+        print(f"Loss with {agg} aggregation for random input:", l_)
 
     # simplified example for ontology with 4 classes, A -> B, B -> C, D -> C, B and D disjoint
     loss.implication_filter_l = torch.tensor(
@@ -528,5 +528,5 @@ def _build_disjointness_filter(
     labels = [[0, 1, 1, 0], [0, 0, 1, 1]]
     for agg in ["sum", "max", "mean", "log-mean"]:
         loss.violations_per_cls_aggregator = agg
-        l = loss(preds, torch.tensor(labels))
-        print(f"Loss with {agg} aggregation for simple input:", l)
+        l_ = loss(preds, torch.tensor(labels))
+        print(f"Loss with {agg} aggregation for simple input:", l_)

chebai/loss/semantic.py

@@ -1,2 +1,4 @@
-from chebai.models.base import *
-from chebai.models.electra import *
+from chebai.models.base import ChebaiBaseNet
+from chebai.models.electra import Electra, ElectraPre
+
+__all__ = ["ChebaiBaseNet", "Electra", "ElectraPre"]