boltzmann9 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

{boltzmann9-0.1.1.dist-info → boltzmann9-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boltzmann9
-Version: 0.1.1
+Version: 0.1.2
 Summary: Restricted Boltzmann Machine implementation in PyTorch
 License: MIT
 Requires-Python: >=3.10

boltzmann9-0.1.2.dist-info/RECORD

@@ -0,0 +1,5 @@
+boltzmann9-0.1.2.dist-info/METADATA,sha256=3ocsO1ccm-6SxfSo5CsBjzQRwLN6LtBXLIr3bS8kgmA,3097
+boltzmann9-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+boltzmann9-0.1.2.dist-info/entry_points.txt,sha256=AZgq8QRNPYvXn6WQspFyXz4U2pcYcwg3RntGcdRXTHY,50
+boltzmann9-0.1.2.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+boltzmann9-0.1.2.dist-info/RECORD,,

boltzmann9-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+

boltzmann/__init__.py

@@ -1,38 +0,0 @@
-"""Boltzmann Machine library for PyTorch."""
-
-from .model import RBM
-from .data import BMDataset, GBMDataloader, split_rbm_loaders
-from .utils import resolve_device, resolve_pin_memory
-from .tester import RBMTester
-from .config import load_config
-from .data_generator import SyntheticDataGenerator, GeneratorConfig
-from .pipeline import train_rbm, evaluate_rbm, save_model, load_model
-from .project import create_project, create_run, list_runs, find_latest_run
-
-__all__ = [
-    # Model
-    "RBM",
-    # Data
-    "BMDataset",
-    "GBMDataloader",
-    "split_rbm_loaders",
-    # Data generation
-    "SyntheticDataGenerator",
-    "GeneratorConfig",
-    # Utils
-    "resolve_device",
-    "resolve_pin_memory",
-    # Testing
-    "RBMTester",
-    # Config & Pipeline
-    "load_config",
-    "train_rbm",
-    "evaluate_rbm",
-    "save_model",
-    "load_model",
-    # Project management
-    "create_project",
-    "create_run",
-    "list_runs",
-    "find_latest_run",
-]

boltzmann/cli.py

@@ -1,389 +0,0 @@
-#!/usr/bin/env python
-"""BoltzmaNN9 command-line interface."""
-
-import argparse
-import sys
-from pathlib import Path
-
-
-def cmd_new_project(args):
-    """Create a new project."""
-    from boltzmann.project import create_project
-
-    try:
-        create_project(args.project_name)
-    except FileExistsError as e:
-        print(f"Error: {e}")
-        return 1
-    return 0
-
-
-def cmd_train(args):
-    """Train a model."""
-    from boltzmann.config import load_config
-    from boltzmann.pipeline import train_rbm, save_model
-    from boltzmann.project import create_run, save_run_config, get_run_paths
-    from boltzmann.run_utils import RunLogger, save_history, save_plots
-
-    project_path = Path(args.project)
-
-    if not project_path.exists():
-        print(f"Error: Project not found: {project_path}")
-        return 1
-
-    config_path = project_path / "config.py"
-    if not config_path.exists():
-        print(f"Error: Config file not found: {config_path}")
-        return 1
-
-    # Create run directory
-    run_dir = create_run(project_path, args.name)
-    paths = get_run_paths(run_dir)
-
-    # Copy config to run
-    save_run_config(run_dir, config_path)
-
-    print(f"Starting training run: {run_dir.name}")
-    print("=" * 60)
-
-    # Train with logging
-    with RunLogger(paths["log"]):
-        # Load config and adjust data path to be relative to project
-        cfg = load_config(config_path)
-
-        # Make data path relative to project
-        data_path = cfg.get("data", {}).get("csv_path", "")
-        if data_path and not Path(data_path).is_absolute():
-            cfg["data"]["csv_path"] = str(project_path / data_path)
-
-        # Import here to avoid circular imports
-        from boltzmann.data import BMDataset, split_rbm_loaders
-        from boltzmann.model import RBM
-        from boltzmann.utils import resolve_device, resolve_pin_memory
-
-        # Setup
-        device = resolve_device(cfg.get("device", "auto"))
-        print(f"Using device: {device}")
-
-        data_cfg = cfg.get("data", {})
-        drop_cols = data_cfg.get("drop_cols", [])
-        dataset = BMDataset(cfg["data"]["csv_path"], drop_cols=drop_cols)
-
-        print(f"Loaded dataset: {len(dataset)} samples")
-        print(f"  Columns: {dataset.columns}")
-
-        dl = cfg.get("dataloader", {})
-        pin_memory = resolve_pin_memory(dl.get("pin_memory", "auto"), device)
-
-        loaders = split_rbm_loaders(
-            dataset,
-            batch_size=dl.get("batch_size", 256),
-            split=tuple(dl.get("split", (0.8, 0.1, 0.1))),
-            seed=dl.get("seed", 42),
-            shuffle_train=dl.get("shuffle_train", True),
-            num_workers=dl.get("num_workers", 0),
-            pin_memory=pin_memory,
-            drop_last_train=dl.get("drop_last_train", True),
-        )
-
-        # Model
-        model_cfg = dict(cfg.get("model", {}))
-        model = RBM(model_cfg).to(device)
-
-        # Train
-        train_cfg = dict(cfg.get("train", {}))
-        history = model.fit(
-            loaders["train"],
-            val_loader=loaders["val"],
-            **train_cfg,
-        )
-
-    # Save outputs
-    import torch
-    checkpoint = {
-        "model_state_dict": model.state_dict(),
-        "nv": model.nv,
-        "nh": model.nh,
-        "config": cfg,
-    }
-    torch.save(checkpoint, paths["model"])
-    print(f"Model saved to: {paths['model']}")
-
-    save_history(history, paths["history"])
-    save_plots(history, paths["plots"], model=model)
-
-    print("\n" + "=" * 60)
-    print("TRAINING COMPLETE")
-    print("=" * 60)
-    print(f"Run directory: {run_dir}")
-    print(f"  - model.pt")
-    print(f"  - config.py")
-    print(f"  - training.log")
-    print(f"  - history.json")
-    print(f"  - plots/")
-
-    return 0
-
-
-def cmd_evaluate(args):
-    """Evaluate a trained model."""
-    from boltzmann.config import load_config
-    from boltzmann.pipeline import load_model
-    from boltzmann.project import get_run_paths, find_latest_run
-    from boltzmann.run_utils import save_metrics
-
-    # Determine run directory
-    run_path = Path(args.run)
-
-    if not run_path.exists():
-        # Maybe it's a project path - find latest run
-        project_path = run_path
-        run_path = find_latest_run(project_path)
-        if run_path is None:
-            print(f"Error: No runs found in project: {project_path}")
-            return 1
-        print(f"Using latest run: {run_path.name}")
-
-    paths = get_run_paths(run_path)
-
-    # Load model and config from run
-    if not paths["model"].exists():
-        print(f"Error: Model not found: {paths['model']}")
-        return 1
-
-    if not paths["config"].exists():
-        print(f"Error: Config not found: {paths['config']}")
-        return 1
-
-    model, saved_cfg = load_model(paths["model"])
-    cfg = load_config(paths["config"])
-
-    # Find project path from run path (output/run_xxx -> project)
-    project_path = run_path.parent.parent
-
-    # Adjust data path
-    data_path = cfg.get("data", {}).get("csv_path", "")
-    if data_path and not Path(data_path).is_absolute():
-        cfg["data"]["csv_path"] = str(project_path / data_path)
-
-    print(f"Evaluating run: {run_path.name}")
-    print("=" * 60)
-
-    # Import and setup
-    from boltzmann.data import BMDataset, split_rbm_loaders
-    from boltzmann.tester import RBMTester
-    from boltzmann.utils import resolve_device, resolve_pin_memory
-
-    device = resolve_device(cfg.get("device", "auto"))
-    model = model.to(device)
-    print(f"Using device: {device}")
-
-    data_cfg = cfg.get("data", {})
-    drop_cols = data_cfg.get("drop_cols", [])
-    dataset = BMDataset(cfg["data"]["csv_path"], drop_cols=drop_cols)
-
-    dl = cfg.get("dataloader", {})
-    pin_memory = resolve_pin_memory(dl.get("pin_memory", "auto"), device)
-
-    loaders = split_rbm_loaders(
-        dataset,
-        batch_size=dl.get("batch_size", 256),
-        split=tuple(dl.get("split", (0.8, 0.1, 0.1))),
-        seed=dl.get("seed", 42),
-        shuffle_train=False,
-        num_workers=dl.get("num_workers", 0),
-        pin_memory=pin_memory,
-        drop_last_train=False,
-    )
-
-    print(f"Evaluating on {len(loaders['test'].dataset)} test samples")
-
-    # Basic metrics
-    eval_cfg = cfg.get("eval", {})
-    test_metrics = model.evaluate(loaders["test"], recon_k=eval_cfg.get("recon_k", 1))
-    print("Test metrics:", test_metrics)
-
-    # Conditional NLL
-    cond_cfg = cfg.get("conditional", {})
-    tester = RBMTester(
-        model=model,
-        test_dataloader=loaders["test"],
-        clamp_idx=cond_cfg["clamp_idx"],
-        target_idx=cond_cfg["target_idx"],
-    )
-    conditional_results = tester.conditional_nll(
-        n_samples=cond_cfg.get("n_samples", 100),
-        burn_in=cond_cfg.get("burn_in", 500),
-        thin=cond_cfg.get("thin", 10),
-    )
-
-    # Save metrics
-    all_metrics = {
-        "test_metrics": test_metrics,
-        "conditional_nll_nats": conditional_results["mean_nll_nats"],
-        "conditional_nll_bits": conditional_results["mean_nll_bits"],
-        "conditional_nll_per_bit": conditional_results["mean_nll_per_bit"],
-        "n_target_bits": conditional_results["n_target_bits"],
-    }
-    save_metrics(all_metrics, paths["metrics"])
-
-    print("\n" + "=" * 60)
-    print("EVALUATION RESULTS")
-    print("=" * 60)
-    print(f"Test metrics: {test_metrics}")
-    print(f"Conditional NLL (nats): {conditional_results['mean_nll_nats']:.4f}")
-    print(f"Conditional NLL (bits): {conditional_results['mean_nll_bits']:.4f}")
-    print(f"Conditional NLL per bit: {conditional_results['mean_nll_per_bit']:.4f}")
-    print(f"Target bits: {conditional_results['n_target_bits']}")
-    print(f"\nMetrics saved to: {paths['metrics']}")
-
-    return 0
-
-
-def cmd_preprocess_raw(args):
-    """Preprocess raw data based on config."""
-    from boltzmann.config import load_config
-    from boltzmann.preprocessor import DataPreprocessor
-
-    config_path = Path(args.config)
-
-    if not config_path.exists():
-        print(f"Error: Config file not found: {config_path}")
-        return 1
-
-    cfg = load_config(config_path)
-
-    print(f"Running preprocessor with config: {config_path}")
-    print("=" * 60)
-
-    preprocessor = DataPreprocessor(cfg, config_dir=config_path.parent)
-    df = preprocessor.fit_transform()
-
-    print(f"\nPreprocessing complete!")
-    print(f"  Output CSV: {preprocessor.output_csv_path}")
-    print(f"  Samples: {len(df)}")
-    print(f"  Columns: {len(df.columns)}")
-    print(f"  Visible blocks: {preprocessor.get_visible_blocks_sizes()}")
-
-    return 0
-
-
-def cmd_list_runs(args):
-    """List all runs in a project."""
-    from boltzmann.project import list_runs
-
-    project_path = Path(args.project)
-
-    if not project_path.exists():
-        print(f"Error: Project not found: {project_path}")
-        return 1
-
-    runs = list_runs(project_path)
-
-    if not runs:
-        print(f"No runs found in: {project_path}")
-        return 0
-
-    print(f"Runs in {project_path}:")
-    print("-" * 40)
-    for run in runs:
-        print(f"  {run.name}")
-
-    return 0
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="BoltzmaNN9 - Restricted Boltzmann Machine toolkit",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # new_project command
-    new_proj_parser = subparsers.add_parser(
-        "new_project",
-        help="Create a new project",
-    )
-    new_proj_parser.add_argument(
-        "project_name",
-        type=str,
-        help="Name/path for the new project",
-    )
-
-    # train command
-    train_parser = subparsers.add_parser(
-        "train",
-        help="Train a model",
-    )
-    train_parser.add_argument(
-        "--project", "-p",
-        type=str,
-        required=True,
-        help="Path to project directory",
-    )
-    train_parser.add_argument(
-        "--name", "-n",
-        type=str,
-        default=None,
-        help="Optional name suffix for the run",
-    )
-
-    # evaluate command
-    eval_parser = subparsers.add_parser(
-        "evaluate",
-        help="Evaluate a trained model",
-    )
-    eval_parser.add_argument(
-        "--run", "-r",
-        type=str,
-        required=True,
-        help="Path to run directory or project (uses latest run)",
-    )
-
-    # list command
-    list_parser = subparsers.add_parser(
-        "list",
-        help="List runs in a project",
-    )
-    list_parser.add_argument(
-        "--project", "-p",
-        type=str,
-        required=True,
-        help="Path to project directory",
-    )
-
-    # preprocess_raw command
-    preprocess_parser = subparsers.add_parser(
-        "preprocess_raw",
-        help="Preprocess raw data using DataPreprocessor",
-    )
-    preprocess_parser.add_argument(
-        "--config", "-c",
-        type=str,
-        required=True,
-        help="Path to config file",
-    )
-
-    args = parser.parse_args()
-
-    if args.command is None:
-        parser.print_help()
-        return 0
-
-    if args.command == "new_project":
-        return cmd_new_project(args)
-    elif args.command == "train":
-        return cmd_train(args)
-    elif args.command == "evaluate":
-        return cmd_evaluate(args)
-    elif args.command == "list":
-        return cmd_list_runs(args)
-    elif args.command == "preprocess_raw":
-        return cmd_preprocess_raw(args)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

boltzmann/config.py

@@ -1,58 +0,0 @@
-"""Configuration loading utilities."""
-
-from __future__ import annotations
-
-import importlib.util
-from pathlib import Path
-from typing import Any, Dict
-
-
-def load_config(config_path: str | Path) -> Dict[str, Any]:
-    """Load configuration from a Python file.
-
-    The config file should contain a dictionary named `config`.
-
-    Args:
-        config_path: Path to the configuration .py file.
-
-    Returns:
-        Configuration dictionary.
-
-    Raises:
-        FileNotFoundError: If config file doesn't exist.
-        ValueError: If config file doesn't contain a 'config' dictionary.
-
-    Example config.py:
-        config = {
-            "device": "auto",
-            "data": {"csv_path": "data.csv", ...},
-            ...
-        }
-    """
-    config_path = Path(config_path)
-
-    if not config_path.exists():
-        raise FileNotFoundError(f"Config file not found: {config_path}")
-
-    # Load the Python file as a module
-    spec = importlib.util.spec_from_file_location("config_module", config_path)
-    if spec is None or spec.loader is None:
-        raise ValueError(f"Could not load config from: {config_path}")
-
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    # Extract the config dictionary
-    if not hasattr(module, "config"):
-        raise ValueError(
-            f"Config file must contain a 'config' dictionary: {config_path}"
-        )
-
-    config = getattr(module, "config")
-
-    if not isinstance(config, dict):
-        raise ValueError(
-            f"'config' must be a dictionary, got {type(config).__name__}"
-        )
-
-    return config

boltzmann/data.py

@@ -1,145 +0,0 @@
-"""Dataset and DataLoader utilities for Boltzmann Machines."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Dict, Sequence
-
-import pandas as pd
-import torch
-from torch.utils.data import Dataset, DataLoader, random_split
-
-
-class BMDataset(Dataset):
-    """PyTorch Dataset for Boltzmann Machine training data.
-
-    Loads data from a CSV file.
-
-    Args:
-        csv_path: Path to CSV file containing the training data.
-            Each row is a sample, columns are features.
-        drop_cols: Optional list of column names to drop from the data.
-    """
-
-    def __init__(
-        self,
-        csv_path: str | Path,
-        drop_cols: Sequence[str] | None = None,
-    ):
-        self.csv_path = Path(csv_path)
-        self.df = pd.read_csv(self.csv_path)
-
-        if drop_cols:
-            self.df = self.df.drop(columns=list(drop_cols))
-
-        self.columns = list(self.df.columns)
-
-    def __len__(self):
-        return len(self.df)
-
-    def __getitem__(self, idx):
-        row = self.df.iloc[idx]
-        x = torch.tensor(row.values, dtype=torch.float32)
-        return x
-
-
-class GBMDataloader:
-    """Simple wrapper around PyTorch DataLoader for Boltzmann Machine data.
-
-    Args:
-        dataset: BMDataset instance.
-        batch_size: Number of samples per batch.
-        shuffle: Whether to shuffle data each epoch.
-        num_workers: Number of worker processes for data loading.
-    """
-
-    def __init__(
-        self,
-        dataset: BMDataset,
-        batch_size: int = 1,
-        shuffle: bool = True,
-        num_workers: int = 0,
-    ):
-        self.loader = DataLoader(
-            dataset,
-            batch_size=batch_size,
-            shuffle=shuffle,
-            num_workers=num_workers,
-        )
-
-    def __iter__(self):
-        return iter(self.loader)
-
-    def __len__(self):
-        return len(self.loader)
-
-
-def split_rbm_loaders(
-    dataset: BMDataset,
-    *,
-    batch_size: int,
-    split: tuple[float, float, float] = (0.8, 0.1, 0.1),
-    seed: int = 42,
-    shuffle_train: bool = True,
-    num_workers: int = 0,
-    pin_memory: bool = True,
-    drop_last_train: bool = True,
-) -> Dict[str, DataLoader]:
-    """Split dataset and create train/val/test DataLoaders.
-
-    Args:
-        dataset: BMDataset to split.
-        batch_size: Number of samples per batch.
-        split: Tuple of (train_frac, val_frac, test_frac). Must sum to 1.0.
-        seed: Random seed for reproducible splits.
-        shuffle_train: Whether to shuffle training data.
-        num_workers: Number of data loading workers.
-        pin_memory: Whether to pin memory (good for CUDA).
-        drop_last_train: Whether to drop last incomplete batch during training.
-
-    Returns:
-        Dictionary with 'train', 'val', 'test' DataLoader instances.
-
-    Raises:
-        ValueError: If split fractions don't sum to 1.0.
-    """
-    train_frac, val_frac, test_frac = split
-    if abs(train_frac + val_frac + test_frac - 1.0) > 1e-6:
-        raise ValueError("split fractions must sum to 1.0")
-
-    n = len(dataset)
-    n_train = int(round(train_frac * n))
-    n_val = int(round(val_frac * n))
-    n_test = n - n_train - n_val
-
-    gen = torch.Generator().manual_seed(seed)
-    train_set, val_set, test_set = random_split(
-        dataset, [n_train, n_val, n_test], generator=gen
-    )
-
-    train_loader = DataLoader(
-        train_set,
-        batch_size=batch_size,
-        shuffle=shuffle_train,
-        drop_last=drop_last_train,
-        num_workers=num_workers,
-        pin_memory=pin_memory,
-    )
-    val_loader = DataLoader(
-        val_set,
-        batch_size=batch_size,
-        shuffle=False,
-        drop_last=False,
-        num_workers=num_workers,
-        pin_memory=pin_memory,
-    )
-    test_loader = DataLoader(
-        test_set,
-        batch_size=batch_size,
-        shuffle=False,
-        drop_last=False,
-        num_workers=num_workers,
-        pin_memory=pin_memory,
-    )
-
-    return {"train": train_loader, "val": val_loader, "test": test_loader}