How to add a custom QSAR classifier scoring component (with prediction probability) in REINVENT 4?

[bishalbudha]

Hi everyone,

I’m trying to integrate a custom QSAR classifier into REINVENT 4 as a scoring component. My goal is to use the probability predicted by the classifier (e.g., predict_proba) as a score during reinforcement learning.

I’ve implemented the plugin like this (saved as reinvent_plugins/custom_rf_scorer.py):

from reinvent_scoring.scoring.score_components.base_score_component import BaseScoreComponent
from reinvent_scoring.scoring.score_component_factory import add_tag
import joblib
import numpy as np
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit.DataStructs.cDataStructs import ConvertToNumpyArray

@add_tag("QSAR_RF")
class QSARRandomForestComponent(BaseScoreComponent):
    def __init__(self, parameters):
        super().__init__(parameters)
        model_file = parameters.specific_parameters.get("model_file", "random_forest_model.pkl")
        self.model = joblib.load(model_file)

    def calculate_score(self, smiles_list, step=-1):
        scores = []
        for smi in smiles_list:
            mol = Chem.MolFromSmiles(smi)
            if mol is None:
                scores.append(0.0)
                continue
            fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=3, nBits=512)
            arr = np.zeros((512,), dtype=int)
            ConvertToNumpyArray(fp, arr)
            prob = self.model.predict_proba(arr.reshape(1, -1))[0, 1]  # probability of class 1
            scores.append(float(prob))
        return scores, smiles_list

Then, in my staged learning TOML configuration, I try to use the model like this:

[[stage.scoring.component]]
[stage.scoring.component.qsar_rf]
class      = "reinvent_plugins.components.comp_custom_qsar_rf.QSARRandomForestComponent"
model_file = "/content/REINVENT4/random_forest_model.pkl"

[[stage.scoring.component.qsar_rf.endpoint]]
name   = "QSAR_RF Probability"
weight = 1.0

---

My questions:

1. Is this the correct way to register a custom scoring component in REINVENT 4?
2. Is the TOML format correct for custom components that use classification probability?
3. Is there an example anywhere of using a plugin with a custom ML model like this?

I’ve tried everything I could find in the docs and GitHub issues, but I can’t figure out what’s missing.

Any help or working example would be greatly appreciated! 🙏

---

[halx]

That doesn't look right (AI generated code?). Have you had a look at the existing scoring components? There are quite a few of them. Also in the contrib/ directory.

For startes, @add_tag is being used wrong and for parameters you need another dataclass with an appropriate @add_tag. There is some rudimentary description in the README.

[bishalbudha]

Yes, it's generated from AI. I don't have any other means so I am compelled.

Sir, from where can I get ideas? The one for staged scoring is written by myself and I hope it's correct.

[bishalbudha]

I can run the rest of staged learning and run too. But, I have been trying to use Qsar for the last seven days but couldn't.

[halx]

comp_qptuna.py is closest to your use case. You should be able to adapt that code.

[bishalbudha]

I’ve reviewed this code, and it expects the model to automatically generate fingerprints and produce predictions. However, my serialized model requires Morgan fingerprints (radius 3, 512 bits) as input in order to make predictions. Could you please help me configure this correctly? Thanks!

[halx]

Approximately as follows. You really need to figure this out yourself.

from rdkit.Chem import rdFingerprintGenerator as FP

@dataclass
class Parameters:
   model_file: List[str]


@add_tag("__component")
class MyQSAR:
    def __init__(self, params: Parameters):
        self.models = []
        self.smiles_type = "rdkit_smiles"  # assumes QSAR model was trained on RDKit canonicalized SMILES

        for filename in params.model_file:
            model = load_model(filename)
            self.models.append(model)

        self.number_of_endpoints = len(params.model_file)
        self.fp_generator = FP.GetMorganGenerator(fpSize=512, radius=3)  # assume the same for all endpoints

    @normalize_smiles
    def __call__(self, smilies: List[str]) -> np.array:
        scores = []
        fps = []

        for smiles in smilies:
            mol = Chem.MolFromSmiles(smiles)
            fp = self.fp_generator.GetFingerprint(mol)
            fps.append(fp)

        for model in self.models:
            model_scores = model.predict_proba(fps)  # adjust as needed
            scores.append(np.array(model_scores))

        return ComponentResults(scores)

[bishalbudha]

---

First of all, a big thank you to @halx — your support has been incredibly valuable, and I truly appreciate the guidance provided across many threads.

That said, I’m stuck with a persistent issue while trying to run a custom scoring component plugin in Google Colab. Here's my situation:

---

🧪 My Setup

• Platform: Google Colab
• Environment: Manually installed Miniconda + Python 3.10
• REINVENT4: Fresh clone from GitHub + install.py cu124 run correctly
• Hijacked kernel: Using sys.executable + sys.path trick to run in the reinvent4 conda env

Everything works smoothly for transfer learning, reinforcement learning, and all other components defined in the configs .

📦 Custom Plugin Added: comp_myqsar.py

I edit your suggested plugin following the pattern of comp_optuna.py, placed it at:

/content/REINVENT4/reinvent_plugins/components/comp_myqsar.py

Here’s a simplified version of the code:

  from __future__ import annotations

__all__ = ["MyQSAR"]
import pickle
from typing import List
import logging
import json

import numpy as np
from pydantic.dataclasses import dataclass

from .component_results import ComponentResults
from .add_tag import add_tag
from ..normalize import normalize_smiles
from rdkit import Chem
from rdkit.Chem import rdFingerprintGenerator as FP

logger = logging.getLogger("reinvent")\

@dataclass
class Parameters:
   model_file: List[str]


@add_tag("__component")
class MyQSAR:
    def __init__(self, params: Parameters):
        self.models = []
        self.smiles_type = "rdkit_smiles"  # assumes QSAR model was trained on RDKit canonicalized SMILES

        for filename in params.model_file:
            model = load_model(filename)
            self.models.append(model)

        self.number_of_endpoints = len(params.model_file)
        self.fp_generator = FP.GetMorganGenerator(fpSize=512, radius=3)  # assume the same for all endpoints

    @normalize_smiles
    def __call__(self, smilies: List[str]) -> np.array:
        scores = []
        fps = []

        for smiles in smilies:
            mol = Chem.MolFromSmiles(smiles)
            fp = self.fp_generator.GetFingerprint(mol)
            fps.append(fp)

        for model in self.models:
            model_scores = model.predict_proba(fps)  # adjust as needed
            scores.append(np.array(model_scores))

        return ComponentResults(scores)

def load_model(filename: str):
    """Load a QSAR pickle model

    :param filename: pickle file name with QSAR model
    :returns: a QSAR model
    """

    with open(filename, "rb") as mfile:
        model = pickle.load(mfile)

    return model

And my toml file is:

---

⚙️ TOML Config (scoring_after_sampling.toml)

run_type = "scoring"
json_out_config = "scoring_all_test_config.json"

[parameters]
smiles_file = "/content/REINVENT4/train_compounds.smi"
output_csv = "scoring_all_test.csv"

[scoring]
type = "geometric_mean"

[[scoring.component]]
[scoring.component.QED]
[[scoring.component.QED.endpoint]]
name = "QED"
weight = 0.55

[[scoring.component]]
[scoring.component.MyQSAR]
[[scoring.component.MyQSAR.endpoint]]
name   = "QSAR"
weight = 0.7
params.model_file = "/content/REINVENT4/random_forest_model.pkl"
transform.type = "sigmoid"
transform.high = 0.8
transform.low  = 0.0
transform.k    = 0.4

---

❌ The Problem

Even after restarting the runtime and running the TOML scoring config, I always get errors like:

KeyError: 'myqsar'
AttributeError: 'NoneType' object has no attribute 'model_file'

I’ve confirmed:

• The file is saved properly.
• The TOML is valid.

---

❓ My Main Confusion

Does REINVENT4 support dynamically added plugins like this in a running Colab session?

Or:

• Is there some cache or module reload trick I need to do?
• Should I be registering the component elsewhere manually?
• Or is it recommended to implement custom logic through .py entrypoints directly like in this discussion:
  Custom QSAR model integration with REINVENT (Staged Learning) not achieving the goal #172?

---

Any clarification or guidance from the maintainers or experienced users would help a lot.

Thank you again 🙏
– Bishal Budha

[halx]

The easiest for you would be to simply copy your component to the same place as the other components. As you have the right naming convention of the filename, one reason why it does not import is because of errors. After installation you should be able to test this with

from reinvent_plugins.components import comp_myqsar