forked from enviPath/enviPy
liambrydon
e26d5a21e3
# Summary
I have introduced a new base `class Dataset` in `ml.py` which all datasets should subclass. It stores the dataset as a polars DataFrame with the column names and number of columns determined by the subclass. It implements generic methods such as `add_row`, `at`, `limit` and dataset saving. It also details abstract methods required by the subclasses. These include `X`, `y` and `generate_dataset`.
There are two subclasses that currently exist. `RuleBasedDataset` for the MLRR models and `EnviFormerDataset` for the enviFormer models.
# Old Dataset to New RuleBasedDataset Functionality Translation
- [x] \_\_init\_\_
- self.columns and self.num_labels moved to base Dataset class
- self.data moved to base class with name self.df along with initialising from list or from another DataFrame
- struct_features, triggered and observed remain the same
- [x] \_block\_indices
- function moved to base Dataset class
- [x] structure_id
- stays in RuleBasedDataset, now requires an index for the row of interest
- [x] add_row
- moved to base Dataset class, now calls add_rows so one or more rows can be added at a time
- [x] times_triggered
- stays in RuleBasedDataset, now does a look up using polars df.filter
- [x] struct_features (see init)
- [x] triggered (see init)
- [x] observed (see init)
- [x] at
- removed in favour of indexing with getitem
- [x] limit
- removed in favour of indexing with getitem
- [x] classification_dataset
- stays in RuleBasedDataset, largely the same just with new dataset construction using add_rows
- [x] generate_dataset
- stays in RuleBasedDataset, largely the same just with new dataset construction using add_rows
- [x] X
- moved to base Dataset as @abstract_method, RuleBasedDataset implementation functionally the same but uses polars
- [x] trig
- stays in RuleBasedDataset, functionally the same but uses polars
- [x] y
- moved to base Dataset as @abstract_method, RuleBasedDataset implementation functionally the same but uses polars
- [x] \_\_get_item\_\_
- moved to base dataset, now passes item to the dataframe for polars to handle
- [x] to_arff
- stays in RuleBasedDataset, functionally the same but uses polars
- [x] \_\_repr\_\_
- moved to base dataset
- [x] \_\_iter\_\_
- moved to base Dataset, now uses polars iter_rows
# Base Dataset class Features
The following functions are available in the base Dataset class
- init - Create the dataset from a list of columns and data in format list of list. Or can create a dataset from a polars Dataframe, this is essential for recreating itself during indexing. Can create an empty dataset by just passing column names.
- add_rows - Add rows to the Dataset, we check that the new data length is the same but it is presumed that the column order matches the existing dataframe
- add_row - Add one row, see add_rows
- block_indices - Returns the column indices that start with the given prefix
- columns - Property, returns dataframe.columns
- shape - Property, returns dataframe.shape
- X - Abstract method to be implemented by the subclasses, it should represent the input to a ML model
- y - Abstract method to be implemented by the subclasses, it should represent the target for a ML model
- generate_dataset - Abstract and static method to be implemented by the subclasses, should return an initialised subclass of Dataset
- iter - returns the iterable from dataframe.iter_rows()
- getitem - passes the item argument to the dataframe. If the result of indexing the dataframe is another dataframe, the new dataframe is packaged into a new Dataset of the same subclass. If the result of indexing is something else (int, float, polar Series) return the result.
- save - Pickle and save the dataframe to the given path
- load - Static method to load the dataset from the given path
- to_numpy - returns the dataframe as a numpy array. Required for compatibility with training of the ECC model
- repr - return a representation of the dataset
- len - return the length of the dataframe
- iter_rows - Return dataframe.iterrows with arguments passed through. Mainly used to get the named iterable which returns rows of the dataframe as dict of column names: column values instead of tuple of column values.
- filter - pass to dataframe.filter and recreates self with the result
- select - pass to dataframe.select and recreates self with the result
- with_columns - pass to dataframe.with_columns and recreates self with the result
- sort - pass to dataframe.sort and recreates self with the result
- item - pass to dataframe.item
- fill_nan - fill the dataframe nan's with value
- height - Property, returns the height (number of rows) of the dataframe
- [x] App domain
- [x] MACCS alternatives
Co-authored-by: Liam Brydon <62733830+MyCreativityOutlet@users.noreply.github.com>
Reviewed-on: enviPath/enviPy#184
Reviewed-by: jebus <lorsbach@envipath.com>
Co-authored-by: liambrydon <lbry121@aucklanduni.ac.nz>
Co-committed-by: liambrydon <lbry121@aucklanduni.ac.nz>
115 lines
4.1 KiB
Python
115 lines
4.1 KiB
Python
from tempfile import TemporaryDirectory
|
|
|
|
import numpy as np
|
|
from django.test import TestCase
|
|
|
|
from epdb.logic import PackageManager
|
|
from epdb.models import User, MLRelativeReasoning, Package, RuleBasedRelativeReasoning
|
|
|
|
|
|
class ModelTest(TestCase):
|
|
fixtures = ["test_fixtures.jsonl.gz"]
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super(ModelTest, cls).setUpClass()
|
|
cls.user = User.objects.get(username="anonymous")
|
|
cls.package = PackageManager.create_package(cls.user, "Anon Test Package", "No Desc")
|
|
cls.BBD_SUBSET = Package.objects.get(name="Fixtures")
|
|
|
|
def test_mlrr(self):
|
|
with TemporaryDirectory() as tmpdir:
|
|
with self.settings(MODEL_DIR=tmpdir):
|
|
threshold = float(0.5)
|
|
|
|
rule_package_objs = [self.BBD_SUBSET]
|
|
data_package_objs = [self.BBD_SUBSET]
|
|
eval_packages_objs = [self.BBD_SUBSET]
|
|
|
|
mod = MLRelativeReasoning.create(
|
|
self.package,
|
|
rule_package_objs,
|
|
data_package_objs,
|
|
threshold=threshold,
|
|
name="ECC - BBD - 0.5",
|
|
description="Created MLRelativeReasoning in Testcase",
|
|
)
|
|
|
|
mod.build_dataset()
|
|
mod.build_model()
|
|
mod.evaluate_model(True, eval_packages_objs, n_splits=2)
|
|
|
|
results = mod.predict("CCN(CC)C(=O)C1=CC(=CC=C1)C")
|
|
|
|
products = dict()
|
|
for r in results:
|
|
for ps in r.product_sets:
|
|
products[tuple(sorted(ps.product_set))] = (r.rule.name, r.probability)
|
|
|
|
expected = {
|
|
("CC=O", "CCNC(=O)C1=CC(C)=CC=C1"): (
|
|
"bt0243-4301",
|
|
np.float64(0.33333333333333337),
|
|
),
|
|
("CC1=CC=CC(C(=O)O)=C1", "CCNCC"): ("bt0430-4011", np.float64(0.25)),
|
|
}
|
|
|
|
self.assertEqual(products, expected)
|
|
|
|
# from pprint import pprint
|
|
# pprint(mod.eval_results)
|
|
|
|
def test_applicability(self):
|
|
with TemporaryDirectory() as tmpdir:
|
|
with self.settings(MODEL_DIR=tmpdir):
|
|
threshold = float(0.5)
|
|
|
|
rule_package_objs = [self.BBD_SUBSET]
|
|
data_package_objs = [self.BBD_SUBSET]
|
|
eval_packages_objs = [self.BBD_SUBSET]
|
|
|
|
mod = MLRelativeReasoning.create(
|
|
self.package,
|
|
rule_package_objs,
|
|
data_package_objs,
|
|
threshold=threshold,
|
|
name="ECC - BBD - 0.5",
|
|
description="Created MLRelativeReasoning in Testcase",
|
|
build_app_domain=True, # To test the applicability domain this must be True
|
|
app_domain_num_neighbours=5,
|
|
app_domain_local_compatibility_threshold=0.5,
|
|
app_domain_reliability_threshold=0.5,
|
|
)
|
|
|
|
mod.build_dataset()
|
|
mod.build_model()
|
|
mod.evaluate_model(True, eval_packages_objs, n_splits=2)
|
|
|
|
results = mod.predict("CCN(CC)C(=O)C1=CC(=CC=C1)C")
|
|
|
|
def test_rbrr(self):
|
|
with TemporaryDirectory() as tmpdir:
|
|
with self.settings(MODEL_DIR=tmpdir):
|
|
threshold = float(0.5)
|
|
|
|
rule_package_objs = [self.BBD_SUBSET]
|
|
data_package_objs = [self.BBD_SUBSET]
|
|
eval_packages_objs = [self.BBD_SUBSET]
|
|
|
|
mod = RuleBasedRelativeReasoning.create(
|
|
self.package,
|
|
rule_package_objs,
|
|
data_package_objs,
|
|
threshold=threshold,
|
|
min_count=5,
|
|
max_count=0,
|
|
name='ECC - BBD - 0.5',
|
|
description='Created MLRelativeReasoning in Testcase',
|
|
)
|
|
|
|
mod.build_dataset()
|
|
mod.build_model()
|
|
mod.evaluate_model(True, eval_packages_objs, n_splits=2)
|
|
|
|
results = mod.predict("CCN(CC)C(=O)C1=CC(=CC=C1)C")
|