smftools 0.1.6__tar.gz → 0.1.7__tar.gz

{smftools-0.1.6 → smftools-0.1.7}/.gitignore

@@ -16,6 +16,7 @@ build/
 /env-*/
 /venv-*/
 venv/
+venvs/
 /environment.yml
 
 # Tests

{smftools-0.1.6 → smftools-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: smftools
-Version: 0.1.6
+Version: 0.1.7
 Summary: Single Molecule Footprinting Analysis in Python.
 Project-URL: Source, https://github.com/jkmckenna/smftools
 Project-URL: Documentation, https://smftools.readthedocs.io/
@@ -118,7 +118,10 @@ The following CLI tools need to be installed and configured before using the inf
 
 ## Announcements
 
-### 10/01/24 - More recent versions are being updated through github and are not currently on pypi, please install from source. Thank you!
+### 05/29/25 - Version 0.1.6 is available through PyPI.
+Informatics, preprocessing, tools, plotting modules have core functionality that is approaching stability on MacOS(Intel/Silicon) and Linux(Ubuntu). I will work on improving documentation/tutorials shortly. The base PyTorch/Scikit-Learn ML-infrastructure is going through some organizational changes to work with PyTorch Lightning, Hydra, and WanDB to facilitate organizational scaling, multi-device usage, and logging.
+
+### 10/01/24 - More recent versions are being updated frequently. Installation from source over PyPI is recommended!
 
 ### 09/09/24 - The version 0.1.1 package ([smftools-0.1.1](https://pypi.org/project/smftools/)) is installable through pypi!
 The informatics module has been bumped to alpha-phase status. This module can deal with POD5s and unaligned BAMS from nanopore conversion and direct SMF experiments, as well as FASTQs from Illumina conversion SMF experiments. Primary output from this module is an AnnData object containing all relevant SMF data, which is compatible with all downstream smftools modules. The other modules are still in pre-alpha phase. Preprocessing, Tools, and Plotting modules should be promoted to alpha-phase within the next month or so.

{smftools-0.1.6 → smftools-0.1.7}/README.md

@@ -29,7 +29,10 @@ The following CLI tools need to be installed and configured before using the inf
 
 ## Announcements
 
-### 10/01/24 - More recent versions are being updated through github and are not currently on pypi, please install from source. Thank you!
+### 05/29/25 - Version 0.1.6 is available through PyPI.
+Informatics, preprocessing, tools, plotting modules have core functionality that is approaching stability on MacOS(Intel/Silicon) and Linux(Ubuntu). I will work on improving documentation/tutorials shortly. The base PyTorch/Scikit-Learn ML-infrastructure is going through some organizational changes to work with PyTorch Lightning, Hydra, and WanDB to facilitate organizational scaling, multi-device usage, and logging.
+
+### 10/01/24 - More recent versions are being updated frequently. Installation from source over PyPI is recommended!
 
 ### 09/09/24 - The version 0.1.1 package ([smftools-0.1.1](https://pypi.org/project/smftools/)) is installable through pypi!
 The informatics module has been bumped to alpha-phase status. This module can deal with POD5s and unaligned BAMS from nanopore conversion and direct SMF experiments, as well as FASTQs from Illumina conversion SMF experiments. Primary output from this module is an AnnData object containing all relevant SMF data, which is compatible with all downstream smftools modules. The other modules are still in pre-alpha phase. Preprocessing, Tools, and Plotting modules should be promoted to alpha-phase within the next month or so.

{smftools-0.1.6 → smftools-0.1.7}/docs/source/installation.md

@@ -1,8 +1,8 @@
 # Installation
 
-## PyPi version
+## PyPi version - Easiest starting point
 
-Pull smftools from [PyPI](https://pypi.org/project/smftools):
+Install smftools from [PyPI](https://pypi.org/project/smftools):
 
 ```shell
 pip install smftools
@@ -33,7 +33,7 @@ chmod +x bedGraphToBigWig
 sudo mv bedGraphToBigWig /usr/local/bin/
 ```
 
-## Development Version
+## Development Version - recommended to use this method for most up to date versions
 
 Clone smftools from source and change into the smftools directory:
 
@@ -42,7 +42,7 @@ git clone https://github.com/jkmckenna/smftools.git
 cd smftools
 ```
 
-A virtual environment can be created for the current version within the smftools directory:
+A python virtual environment can be created as an alternative to conda. I like to do venv-smftools-X.X.X to keep a seperate venv for each version:
 
 ```shell
 python -m venv venv-smftools

{smftools-0.1.6 → smftools-0.1.7}/pyproject.toml

@@ -97,7 +97,7 @@ docs = [
 sources = ["src"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["smftools"]
+include = ["smftools"]
 
 [tool.hatch.version]
 path = "src/smftools/_version.py"

smftools-0.1.7/smftools/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.7"

smftools-0.1.7/smftools/tools/data/__init__.py

@@ -0,0 +1,2 @@
+from .anndata_data_module import AnnDataModule
+from .preprocessing import random_fill_nans

smftools-0.1.7/smftools/tools/data/anndata_data_module.py

@@ -0,0 +1,90 @@
+import torch
+from torch.utils.data import DataLoader, TensorDataset, random_split
+import pytorch_lightning as pl
+import numpy as np
+import pandas as pd
+
+class AnnDataModule(pl.LightningDataModule):
+    def __init__(self, adata, tensor_source="X", tensor_key=None, label_col="labels", 
+                 batch_size=64, train_frac=0.7, random_seed=42, split_col='train_val_split', split_save_path=None, load_existing_split=False,
+                 inference_mode=False):
+        super().__init__()
+        self.adata = adata # The adata object
+        self.tensor_source = tensor_source # X, layers, obsm
+        self.tensor_key = tensor_key  # name of the layer or obsm key
+        self.label_col = label_col # name of the label column in obs
+        self.batch_size = batch_size
+        self.train_frac = train_frac
+        self.random_seed = random_seed
+        self.split_col = split_col  # Name of obs column to store "train"/"val"
+        self.split_save_path = split_save_path # Where to save the obs_names and train/test split logging
+        self.load_existing_split = load_existing_split # Whether to load from an existing split
+        self.inference_mode = inference_mode # Whether to load the AnnDataModule in inference mode.
+
+    def setup(self, stage=None):
+        # Load feature matrix
+        if self.tensor_source == "X":
+            X = self.adata.X
+        elif self.tensor_source == "layers":
+            assert self.tensor_key in self.adata.layers, f"Layer '{self.tensor_key}' not found."
+            X = self.adata.layers[self.tensor_key]
+        elif self.tensor_source == "obsm":
+            assert self.tensor_key in self.adata.obsm, f"obsm key '{self.tensor_key}' not found."
+            X = self.adata.obsm[self.tensor_key]
+        else:
+            raise ValueError(f"Invalid tensor_source: {self.tensor_source}")
+
+        # Convert to tensor
+        X_tensor = torch.tensor(X, dtype=torch.float32)
+
+        if self.inference_mode:
+            self.infer_dataset = TensorDataset(X_tensor)
+
+        else:
+            # Load and encode labels
+            y = self.adata.obs[self.label_col]
+            if y.dtype.name == 'category':
+                y = y.cat.codes
+            y_tensor = torch.tensor(y.values, dtype=torch.long)
+
+            # Use existing split
+            if self.load_existing_split:
+                split_df = pd.read_csv(self.split_save_path, index_col=0)
+                assert self.split_col in split_df.columns, f"'{self.split_col}' column missing in split file."
+                self.adata.obs[self.split_col] = split_df.loc[self.adata.obs_names][self.split_col].values
+
+            # If no split exists, create one
+            if self.split_col not in self.adata.obs:
+                full_dataset = TensorDataset(X_tensor, y_tensor)
+                n_train = int(self.train_frac * len(full_dataset))
+                n_val = len(full_dataset) - n_train
+                self.train_set, self.val_set = random_split(
+                    full_dataset, [n_train, n_val],
+                    generator=torch.Generator().manual_seed(self.random_seed)
+                )
+                # Assign split labels
+                split_array = np.full(len(self.adata), "val", dtype=object)
+                train_idx = self.train_set.indices if hasattr(self.train_set, "indices") else self.train_set._indices
+                split_array[train_idx] = "train"
+                self.adata.obs[self.split_col] = split_array
+
+                # Save to disk
+                if self.split_save_path:
+                    self.adata.obs[[self.split_col]].to_csv(self.split_save_path)
+            else:
+                split_labels = self.adata.obs[self.split_col].values
+                train_mask = split_labels == "train"
+                val_mask = split_labels == "val"
+                self.train_set = TensorDataset(X_tensor[train_mask], y_tensor[train_mask])
+                self.val_set = TensorDataset(X_tensor[val_mask], y_tensor[val_mask])
+
+    def train_dataloader(self):
+        return DataLoader(self.train_set, batch_size=self.batch_size, shuffle=True)
+
+    def val_dataloader(self):
+        return DataLoader(self.val_set, batch_size=self.batch_size)
+    
+    def predict_dataloader(self):
+        if not self.inference_mode:
+            raise RuntimeError("predict_dataloader only available in inference mode.")
+        return DataLoader(self.infer_dataset, batch_size=self.batch_size)

smftools-0.1.7/smftools/tools/inference/__init__.py

@@ -0,0 +1 @@
+from .lightning_inference import run_lightning_inference

smftools-0.1.7/smftools/tools/inference/lightning_inference.py

@@ -0,0 +1,41 @@
+import torch
+import pandas as pd
+import numpy as np
+from pytorch_lightning import Trainer
+
+def run_lightning_inference(
+    adata,
+    model,
+    datamodule,
+    label_col="labels",
+    prefix="model"
+):
+
+    # Get class labels
+    if label_col in adata.obs and pd.api.types.is_categorical_dtype(adata.obs[label_col]):
+        class_labels = adata.obs[label_col].cat.categories.tolist()
+    else:
+        raise ValueError("label_col must be a categorical column in adata.obs")
+
+    # Run predictions
+    trainer = Trainer(accelerator="auto", devices=1, logger=False, enable_checkpointing=False)
+    preds = trainer.predict(model, datamodule=datamodule)
+    probs = torch.cat(preds, dim=0).cpu().numpy()  # (N, C)
+    pred_class_idx = probs.argmax(axis=1)
+    pred_class_labels = [class_labels[i] for i in pred_class_idx]
+    pred_class_probs = probs[np.arange(len(probs)), pred_class_idx]
+
+    # Construct full prefix with label_col
+    full_prefix = f"{prefix}_{label_col}"
+
+    # Store predictions in obs
+    adata.obs[f"{full_prefix}_pred"] = pred_class_idx
+    adata.obs[f"{full_prefix}_pred_label"] = pd.Categorical(pred_class_labels, categories=class_labels)
+    adata.obs[f"{full_prefix}_pred_prob"] = pred_class_probs
+
+    # Per-class probabilities
+    for i, class_name in enumerate(class_labels):
+        adata.obs[f"{full_prefix}_prob_{class_name}"] = probs[:, i]
+
+    # Full probability matrix in obsm
+    adata.obsm[f"{full_prefix}_pred_prob_all"] = probs

{smftools-0.1.6 → smftools-0.1.7}/smftools/tools/models/__init__.py

@@ -4,4 +4,6 @@ from .cnn import CNNClassifier
 from .rnn import RNNClassifier
 from .transformer import BaseTransformer, TransformerClassifier, DANNTransformerClassifier, MaskedTransformerPretrainer
 from .positional import PositionalEncoding
-from .wrappers import ScaledModel
+from .wrappers import ScaledModel
+from .lightning_base import TorchClassifierWrapper
+from .sklearn_models import SklearnModelWrapper

smftools-0.1.7/smftools/tools/models/lightning_base.py

@@ -0,0 +1,41 @@
+import torch
+import pytorch_lightning as pl
+
+class TorchClassifierWrapper(pl.LightningModule):
+    def __init__(
+        self,
+        model: torch.nn.Module,
+        optimizer_cls=torch.optim.AdamW,
+        optimizer_kwargs=None,
+        criterion_cls=torch.nn.CrossEntropyLoss,
+        criterion_kwargs=None,
+        lr: float = 1e-3,
+    ):
+        super().__init__()
+        self.model = model
+        self.save_hyperparameters(ignore=['model'])  # logs all except actual model instance
+        self.optimizer_cls = optimizer_cls
+        self.optimizer_kwargs = optimizer_kwargs or {}
+        self.criterion = criterion_cls(**(criterion_kwargs or {}))
+        self.lr = lr
+
+    def forward(self, x):
+        return self.model(x)
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = self.criterion(logits, y)
+        self.log("train_loss", loss, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = self.criterion(logits, y)
+        acc = (logits.argmax(dim=1) == y).float().mean()
+        self.log_dict({"val_loss": loss, "val_acc": acc}, prog_bar=True)
+        return loss
+
+    def configure_optimizers(self):
+        return self.optimizer_cls(self.parameters(), lr=self.lr, **self.optimizer_kwargs)

smftools-0.1.7/smftools/tools/models/sklearn_models.py

@@ -0,0 +1,40 @@
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import (
+    roc_curve, precision_recall_curve, auc, f1_score, confusion_matrix
+)
+from sklearn.utils.class_weight import compute_class_weight
+
+import numpy as np
+
+class SklearnModelWrapper:
+    def __init__(self, model):
+        self.model = model
+
+    def fit(self, X_train, y_train):
+        self.model.fit(X_train, y_train)
+
+    def predict(self, X):
+        return self.model.predict(X)
+
+    def predict_proba(self, X):
+        return self.model.predict_proba(X)
+
+    def evaluate(self, X_test, y_test):
+        probs = self.predict_proba(X_test)[:, 1]
+        preds = self.predict(X_test)
+
+        fpr, tpr, _ = roc_curve(y_test, probs)
+        precision, recall, _ = precision_recall_curve(y_test, probs)
+        f1 = f1_score(y_test, preds)
+        auc_score = auc(fpr, tpr)
+        pr_auc = auc(recall, precision)
+        cm = confusion_matrix(y_test, preds)
+        pos_freq = np.mean(y_test == 1)
+        pr_auc_norm = pr_auc / pos_freq
+
+        return {
+            "fpr": fpr, "tpr": tpr, "precision": precision, "recall": recall,
+            "f1": f1, "auc": auc_score, "pr_auc": pr_auc,
+            "pr_auc_norm": pr_auc_norm, "confusion_matrix": cm
+        }

smftools-0.1.7/smftools/tools/training/__init__.py

@@ -0,0 +1 @@
+from .train_lightning_model import train_lightning_model

smftools-0.1.7/smftools/tools/training/train_lightning_model.py

@@ -0,0 +1,47 @@
+import torch
+from pytorch_lightning import Trainer
+from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
+
+def train_lightning_model(
+    model,
+    datamodule,
+    max_epochs=20,
+    patience=5,
+    monitor_metric="val_loss",
+    checkpoint_path=None,
+):
+    # Device logic
+    if torch.cuda.is_available():
+        accelerator = "gpu"
+        devices = 1
+    elif torch.backends.mps.is_available():
+        accelerator = "mps"
+        devices = 1
+    else:
+        accelerator = "cpu"
+        devices = 1
+
+    # Callbacks
+    callbacks = [
+        EarlyStopping(monitor=monitor_metric, patience=patience, mode="min"),
+    ]
+    if checkpoint_path:
+        callbacks.append(ModelCheckpoint(
+            dirpath=checkpoint_path,
+            filename="{epoch}-{val_loss:.4f}",
+            monitor=monitor_metric,
+            save_top_k=1,
+            mode="min",
+        ))
+
+    # Trainer setup
+    trainer = Trainer(
+        max_epochs=max_epochs,
+        callbacks=callbacks,
+        accelerator=accelerator,
+        devices=devices,
+        log_every_n_steps=10,
+    )
+    trainer.fit(model, datamodule=datamodule)
+    
+    return trainer

smftools-0.1.6/smftools/_version.py

@@ -1 +0,0 @@
-__version__ = "0.1.6"

smftools-0.1.6/smftools/tools/data/__init__.py

@@ -1 +0,0 @@
-from .preprocessing import random_fill_nans