graflag-bond 1.0.0__tar.gz

graflag_bond-1.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: graflag_bond
+Version: 1.0.0
+Summary: Universal PyGOD detector wrapper for GraFlag BOND methods
+Author: GraFlag Team
+Requires-Python: >=3.7
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torch-geometric>=2.3.0
+Requires-Dist: pygod>=1.1.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scikit-learn>=1.3.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

graflag_bond-1.0.0/__init__.py

@@ -0,0 +1,15 @@
+"""
+GraFlag Bond - Generic PyGOD Detector Wrapper
+
+This library provides a unified interface for running PyGOD anomaly detection
+methods through the GraFlag framework.
+"""
+
+from .detectors import BondDetector
+from .utils import get_all_parameters
+
+__version__ = "1.0.0"
+__all__ = [
+    "BondDetector",
+    "get_all_parameters"
+]

graflag_bond-1.0.0/detectors.py

@@ -0,0 +1,88 @@
+"""
+PyGOD Detector Enumeration
+
+Dynamically discovers and maps all PyGOD detector classes.
+"""
+
+import inspect
+import pygod.detector
+
+
+class BondDetector:
+    """Dynamic PyGOD detector registry."""
+    
+    _detectors = None
+    
+    @classmethod
+    def _load_detectors(cls):
+        """Load all detector classes from pygod.detector module."""
+        if cls._detectors is not None:
+            return
+        
+        cls._detectors = {}
+        
+        # Inspect pygod.detector module for all classes
+        for name, obj in inspect.getmembers(pygod.detector, inspect.isclass):
+            # Filter to only include classes defined in pygod.detector
+            if obj.__module__.startswith('pygod.detector'):
+                # Store with lowercase name as key
+                cls._detectors[name.lower()] = obj
+    
+    @classmethod
+    def from_method_name(cls, method_name: str):
+        """
+        Get detector class from method name.
+        
+        Args:
+            method_name: Method name (e.g., 'bond_dominant', 'dominant', 'DOMINANT')
+            
+        Returns:
+            Detector class name (lowercase)
+            
+        Raises:
+            ValueError: If method name is not supported
+        """
+        cls._load_detectors()
+        
+        # Remove bond_ prefix if present and convert to lowercase
+        name = method_name.lower().replace("bond_", "")
+        
+        if name not in cls._detectors:
+            supported = ", ".join(sorted(cls._detectors.keys()))
+            raise ValueError(f"Unsupported detector: {name}. Supported: {supported}")
+        
+        return name
+    
+    @classmethod
+    def get_detector_class(cls, detector_name: str):
+        """
+        Get the PyGOD detector class by name.
+        
+        Args:
+            detector_name: Detector name (e.g., 'dominant', 'adone')
+            
+        Returns:
+            PyGOD detector class
+            
+        Raises:
+            ValueError: If detector name is not found
+        """
+        cls._load_detectors()
+        
+        name = detector_name.lower()
+        if name not in cls._detectors:
+            supported = ", ".join(sorted(cls._detectors.keys()))
+            raise ValueError(f"Detector not found: {name}. Available: {supported}")
+        
+        return cls._detectors[name]
+    
+    @classmethod
+    def list_detectors(cls):
+        """
+        List all available detector names.
+        
+        Returns:
+            List of detector names (lowercase)
+        """
+        cls._load_detectors()
+        return sorted(cls._detectors.keys())

graflag_bond-1.0.0/graflag_bond.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: graflag_bond
+Version: 1.0.0
+Summary: Universal PyGOD detector wrapper for GraFlag BOND methods
+Author: GraFlag Team
+Requires-Python: >=3.7
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torch-geometric>=2.3.0
+Requires-Dist: pygod>=1.1.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scikit-learn>=1.3.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

graflag_bond-1.0.0/graflag_bond.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+__init__.py
+detectors.py
+setup.py
+train.py
+utils.py
+./__init__.py
+./detectors.py
+./train.py
+./utils.py
+graflag_bond.egg-info/PKG-INFO
+graflag_bond.egg-info/SOURCES.txt
+graflag_bond.egg-info/dependency_links.txt
+graflag_bond.egg-info/requires.txt
+graflag_bond.egg-info/top_level.txt

graflag_bond-1.0.0/graflag_bond.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graflag_bond-1.0.0/graflag_bond.egg-info/requires.txt

@@ -0,0 +1,5 @@
+torch>=2.0.0
+torch-geometric>=2.3.0
+pygod>=1.1.0
+numpy>=1.24.0
+scikit-learn>=1.3.0

graflag_bond-1.0.0/graflag_bond.egg-info/top_level.txt

@@ -0,0 +1 @@
+graflag_bond

graflag_bond-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graflag_bond-1.0.0/setup.py

@@ -0,0 +1,20 @@
+"""Setup script for graflag_bond package."""
+
+from setuptools import setup
+
+setup(
+    name="graflag_bond",
+    version="1.0.0",
+    description="Universal PyGOD detector wrapper for GraFlag BOND methods",
+    author="GraFlag Team",
+    packages=["graflag_bond"],
+    package_dir={"graflag_bond": "."},
+    install_requires=[
+        "torch>=2.0.0",
+        "torch-geometric>=2.3.0",
+        "pygod>=1.1.0",
+        "numpy>=1.24.0",
+        "scikit-learn>=1.3.0",
+    ],
+    python_requires=">=3.7",
+)

graflag_bond-1.0.0/train.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Generic PyGOD Bond Training Script
+
+This script trains any PyGOD detector based on METHOD_NAME environment variable.
+"""
+
+import os
+import sys
+import time
+from pathlib import Path
+
+import psutil
+import torch
+
+# Import graflag_runner utilities
+from graflag_runner import ResultWriter
+from graflag_runner import info, warning, error
+
+# Import PyGOD
+from pygod.utils import load_data
+
+# Import bond utilities
+from graflag_bond.detectors import BondDetector
+from graflag_bond.utils import get_all_parameters
+
+
+def load_graph_data(data_dir):
+    """Load graph data from PyGOD datasets."""
+    
+    supported_data = os.environ.get("SUPPORTED_DATA", "").split(", ")
+    dataset_name = data_dir.name
+    
+    if supported_data and dataset_name not in supported_data:
+        warning(f"Dataset '{dataset_name}' may not be officially tested. Supported: {supported_data}")
+    
+    info(f"Loading dataset: {dataset_name} from {data_dir}")
+
+    # Load data using PyGOD's load_data
+    data = load_data(dataset_name, cache_dir=data_dir)
+    info(f"Graph: {data.num_nodes} nodes, {data.num_edges} edges, {data.num_features} features")
+    
+    return data
+
+
+def train_detector(method_name, data, exp_dir, writer):
+    """Train PyGOD detector."""
+    
+    # Get detector name and class dynamically
+    detector_name = BondDetector.from_method_name(method_name)
+    detector_class = BondDetector.get_detector_class(detector_name)
+    
+    # Get parameters from environment with type hints from detector signature
+    params = get_all_parameters(detector_class)
+    
+    info("=" * 60)
+    info(f"Training {detector_name.upper()} Model")
+    info("=" * 60)
+    
+    # Log key parameters
+    info(f"Detector: {detector_class.__name__}")
+    if "hid_dim" in params:
+        info(f"Architecture: hid_dim={params['hid_dim']}, num_layers={params.get('num_layers', 'N/A')}")
+    if "epoch" in params:
+        info(f"Training: epochs={params['epoch']}, lr={params.get('lr', 'N/A')}")
+    if "contamination" in params:
+        info(f"Contamination: {params['contamination']}")
+    
+    # Initialize model
+    info(f"Initializing {detector_name.upper()} detector...")
+    model = detector_class(**params)
+    
+    # Train model
+    info("Starting training...")
+    start_time = time.time()
+    model.fit(data)
+    training_time = time.time() - start_time
+    
+    # Log training metrics
+    writer.spot("training", 
+                epochs=params.get('epoch', 'N/A'),
+                training_time_sec=training_time)
+
+    info(f"Training completed in {training_time:.2f}s")
+
+    return model
+
+
+def save_results(model, data, exp_dir, writer, method_name, dataset_name,
+                 exec_time_ms, peak_memory_mb, peak_gpu_mb=None):
+    """Save results with metadata and resource metrics."""
+    info("=" * 60)
+    info("Generating Results")
+    info("=" * 60)
+
+    # Get anomaly scores
+    scores = model.decision_score_
+
+    # Get ground truth labels from data (binarize: 0=normal, any non-zero=anomaly)
+    gt_raw = data.y.cpu() if hasattr(data.y, 'cpu') else data.y
+    ground_truth = [1 if label != 0 else 0 for label in gt_raw]
+
+    # Save results using ResultWriter
+    writer.save_scores(
+        result_type="NODE_ANOMALY_SCORES",
+        scores=scores.tolist(),
+        ground_truth=ground_truth,
+        node_ids=list(range(len(scores)))
+    )
+
+    # Get detector info
+    detector_name = BondDetector.from_method_name(method_name)
+    detector_class = BondDetector.get_detector_class(detector_name)
+    params = get_all_parameters(detector_class)
+
+    # Convert params to JSON-safe strings (some values are Python types/functions)
+    safe_params = {}
+    for k, v in params.items():
+        if callable(v) or isinstance(v, type):
+            safe_params[k] = f"{v.__module__}.{v.__qualname__}" if hasattr(v, '__module__') else str(v)
+        else:
+            safe_params[k] = v
+
+    # Add metadata
+    writer.add_metadata(
+        exp_name=os.path.basename(os.environ.get("EXP", "experiment")),
+        method_name=method_name,
+        dataset=dataset_name,
+        method_parameters=safe_params,
+        threshold=None,
+        summary={
+            "description": f"PyGOD {detector_name.upper()} detector",
+            "task": "node_anomaly_detection",
+            "dataset_info": {
+                "name": dataset_name,
+                "num_nodes": data.num_nodes,
+                "num_edges": data.num_edges,
+                "num_features": data.num_features,
+                "num_anomalies": sum(ground_truth),
+            },
+        },
+    )
+
+    # Add resource metrics
+    writer.add_resource_metrics(
+        exec_time_ms=exec_time_ms,
+        peak_memory_mb=peak_memory_mb,
+        peak_gpu_mb=peak_gpu_mb,
+    )
+
+    # Finalize results
+    writer.finalize()
+
+    info(f"Results saved to {exp_dir}")
+
+
+def main():
+    # Get environment variables
+    method_name = os.environ.get("METHOD_NAME")
+    if not method_name:
+        error("METHOD_NAME environment variable not set!")
+        sys.exit(1)
+
+    data_dir = Path(os.environ.get("DATA"))
+    exp_dir = Path(os.environ.get("EXP"))
+
+    info("=" * 60)
+    info(f"PyGOD Bond: {method_name.upper()}")
+    info("=" * 60)
+    info(f"Dataset: {data_dir}")
+    info(f"Output: {exp_dir}")
+    info("")
+
+    # Create experiment directory
+    exp_dir.mkdir(parents=True, exist_ok=True)
+
+    # Start resource tracking
+    start_time = time.time()
+    process = psutil.Process()
+    peak_memory_mb = 0.0
+
+    # Initialize ResultWriter
+    writer = ResultWriter()
+
+    try:
+        # Load data
+        data = load_graph_data(data_dir)
+
+        # Track memory
+        peak_memory_mb = max(peak_memory_mb, process.memory_info().rss / (1024 * 1024))
+
+        # Train model
+        model = train_detector(method_name, data, exp_dir, writer)
+
+        # Track memory after training
+        peak_memory_mb = max(peak_memory_mb, process.memory_info().rss / (1024 * 1024))
+
+        # Calculate resource metrics
+        end_time = time.time()
+        exec_time_ms = (end_time - start_time) * 1000
+
+        # Track GPU memory if available
+        peak_gpu_mb = None
+        if torch.cuda.is_available():
+            gpu_bytes = torch.cuda.max_memory_allocated()
+            if gpu_bytes > 0:
+                peak_gpu_mb = gpu_bytes / (1024 * 1024)
+
+        # Save results with metadata and resource metrics
+        save_results(model, data, exp_dir, writer, method_name, data_dir.name,
+                     exec_time_ms, peak_memory_mb, peak_gpu_mb)
+
+        info("")
+        info(f"[INFO] Resource Usage:")
+        info(f"   [INFO] Execution time: {exec_time_ms/1000:.2f}s")
+        info(f"   [INFO] Peak memory: {peak_memory_mb:.2f}MB")
+        if peak_gpu_mb is not None:
+            info(f"   [INFO] Peak GPU memory: {peak_gpu_mb:.2f}MB")
+
+        info("")
+        info("=" * 60)
+        info(f"{method_name.upper()} execution completed successfully!")
+        info("=" * 60)
+
+    except Exception as e:
+        error(f"Error during execution: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

graflag_bond-1.0.0/utils.py

@@ -0,0 +1,186 @@
+"""
+Utility functions for graflag_bond.
+
+Dynamically handles parameter extraction from environment variables.
+Converts values to appropriate Python types based on parameter names and values.
+"""
+
+import os
+from typing import Dict, Any
+import torch.nn.functional as F
+
+
+def str_to_bool(value: str) -> bool:
+    """Convert string to boolean."""
+    return value.lower() in ('true', '1', 'yes')
+
+
+def get_activation_function(activation_value: str):
+    """
+    Convert activation function path/name to PyTorch activation function.
+    Handles any torch.nn.functional activation function dynamically.
+    
+    Args:
+        activation_value: Activation function path (e.g., 'torch.nn.functional.relu')
+        
+    Returns:
+        PyTorch activation function
+    """
+    # Extract function name from full path
+    if 'torch.nn.functional.' in activation_value:
+        func_name = activation_value.split('.')[-1]
+    else:
+        func_name = activation_value
+    
+    # Get the function from torch.nn.functional
+    if hasattr(F, func_name):
+        return getattr(F, func_name)
+    else:
+        # Default to relu if function not found
+        return F.relu
+
+
+def get_backbone_class(backbone_value: str):
+    """
+    Convert backbone path to PyTorch Geometric class.
+    Handles any torch_geometric.nn class dynamically.
+    
+    Args:
+        backbone_value: Backbone class path (e.g., 'torch_geometric.nn.GCN')
+        
+    Returns:
+        PyTorch Geometric class or None
+    """
+    if backbone_value.lower() == 'none':
+        return None
+    
+    try:
+        # Extract class name from full path
+        if 'torch_geometric.nn.' in backbone_value:
+            class_name = backbone_value.split('.')[-1]
+        else:
+            class_name = backbone_value
+        
+        # Import torch_geometric.nn
+        import torch_geometric.nn as pyg_nn
+        
+        # Get the class dynamically
+        if hasattr(pyg_nn, class_name):
+            return getattr(pyg_nn, class_name)
+        else:
+            return None
+    except ImportError:
+        return None
+
+
+def convert_env_value(env_name: str, env_value: str, expected_type: type = None) -> Any:
+    """
+    Convert environment variable value to appropriate Python type.
+    
+    Args:
+        env_name: Name of environment variable (uppercase)
+        env_value: String value from environment
+        expected_type: Expected type from function signature (if available)
+        
+    Returns:
+        Converted value with appropriate type
+    """
+    # Handle activation functions (callable)
+    if 'torch.nn.functional' in env_value:
+        return get_activation_function(env_value)
+    
+    # Handle backbone classes (torch.nn.Module)
+    if 'torch_geometric.nn' in env_value:
+        return get_backbone_class(env_value)
+    
+    # Handle None
+    if env_value.lower() == 'none':
+        return None
+    
+    # Handle boolean values
+    if env_value.lower() in ['true', 'false']:
+        return str_to_bool(env_value)
+    
+    # If we have expected type from signature, use it
+    if expected_type is not None:
+        try:
+            if expected_type == float:
+                return float(env_value)
+            elif expected_type == int:
+                return int(env_value)
+            elif expected_type == bool:
+                return str_to_bool(env_value)
+            elif expected_type == str:
+                return env_value
+        except (ValueError, TypeError):
+            pass
+    
+    # Fallback: Try to detect type from value
+    try:
+        # Try int first (if no decimal point)
+        if '.' not in env_value:
+            return int(env_value)
+        
+        # Has decimal point, convert to float
+        return float(env_value)
+    except (ValueError, AttributeError):
+        pass
+    
+    # Return as string if conversion fails
+    return env_value
+
+
+def get_all_parameters(detector_class=None) -> Dict[str, Any]:
+    """
+    Get all parameters from environment variables.
+    Only reads environment variables prefixed with underscore (_PARAM_NAME).
+    Automatically converts parameter names from _UPPER_CASE to lower_case
+    and values to appropriate Python types based on detector signature.
+    
+    Args:
+        detector_class: Optional detector class to inspect for parameter types
+    
+    Returns:
+        Dictionary of all parameters with correct types
+    """
+    import inspect
+    
+    params = {}
+    
+    # Get parameter types from detector signature if available
+    param_types = {}
+    if detector_class is not None:
+        try:
+            sig = inspect.signature(detector_class.__init__)
+            for param_name, param in sig.parameters.items():
+                if param_name in ['self', 'args', 'kwargs']:
+                    continue
+                
+                # First try to get type from annotation
+                if param.annotation != inspect.Parameter.empty:
+                    param_types[param_name] = param.annotation
+                # If no annotation, get type from default value
+                elif param.default != inspect.Parameter.empty and param.default is not None:
+                    param_types[param_name] = type(param.default)
+        except (ValueError, TypeError):
+            pass
+    
+    # Iterate through all environment variables
+    for env_name, env_value in os.environ.items():
+        # Only process variables that start with underscore
+        if not env_name.startswith('_'):
+            continue
+        
+        # Remove underscore prefix and convert to lowercase
+        param_name = env_name[1:].lower()
+        
+        # Get expected type from signature
+        expected_type = param_types.get(param_name)
+        
+        # Convert value to appropriate type
+        param_value = convert_env_value(env_name, env_value, expected_type)
+        
+        # Add to parameters
+        params[param_name] = param_value
+    
+    return params