Add custom model

You can leverage the TACT infrastructure to create custom adjustment models by extending the base AdjustmentMethod class. This guide will show you how to create and register your own model.

Overview

A valid adjustment method must:

Define required input parameters
Specify required data columns
Implement the adjustment logic
Register with TACT’s registry system

Creating Your Custom Model Package

The recommended way to create custom models is to keep them in your own project, separate from the TACT installation. Here’s a typical project structure:

your_project/
├── custom_adjustments/
│   ├── __init__.py
│   └── my_method.py    # Your custom method
├── examples/
│   └── use_custom_method.py
├── README.md
└── setup.py           # Optional, if you want to package your models

Creating a Custom Model

Here’s an example of creating a simple custom adjustment model:

# custom_adjustments/my_method.py

from typing import Dict, Any, List
import pandas as pd
from tact.core.base import AdjustmentMethod
from tact.core.registry import AdjustmentRegistry

@AdjustmentRegistry.register("my-custom-method")
class CustomAdjustment(AdjustmentMethod):
    """Custom turbulence intensity adjustment method.
    
    This method implements a custom adjustment algorithm for 
    turbulence intensity measurements.
    
    Parameters
    ----------
    config_path : str
        Path to configuration file
    custom_param : float
        Custom scaling factor for adjustment
    """
    
    def required_model_parameters(self) -> Dict[str, List]:
        return {
            "config_path": str,  # Path to configuration file
            "custom_param": float  # Your custom parameter
        }
    
    def required_data_columns(self) -> List[str]:
        return [
            "reference.wind_speed",
            "reference.turbulence_intensity",
            "rsd.height_1.wind_speed",
            "rsd.height_1.turbulence_intensity"
        ]
    
    def adjust(self, data: pd.DataFrame, parameters: Dict[str, Any]) -> Dict[str, Any]:
        # Validate inputs
        self.validate_parameters(parameters)
        self.validate_data(data, parameters["config_path"])
        
        # Your adjustment logic here
        adjusted_data = data.copy()
        custom_factor = parameters["custom_param"]
        
        # Example adjustment
        adjusted_data["adjusted_ti"] = data["rsd.height_1.turbulence_intensity"] * custom_factor
        
        return {
            "adjusted_data": adjusted_data,
            "metrics": {"custom_factor": custom_factor}
        }

Using Your Custom Model

To use your custom model, simply import and register it before using TACT:

# examples/use_custom_method.py

# Import your custom method
from custom_adjustments.my_method import CustomAdjustment

# Now import and use TACT as normal
from tact import TACT

# Initialize TACT
tact = TACT()

# Your custom method is now available
results = tact.adjust(
    data=data,
    method="my-custom-method",
    parameters={
        "config_path": "path/to/config.json",
        "custom_param": 1.2
    }
)

The registration system will automatically make your method available to TACT when it’s imported. You don’t need to modify the TACT package itself.

Optional: Packaging Your Models

If you want to share your custom models, you can package them:

Create a setup.py:

from setuptools import setup, find_packages

setup(
    name="tact-custom-methods",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[
        "tact",  # This will ensure TACT is installed
    ],
)

Install your package:

pip install -e .

Implementation Guide

Class Structure

Your adjustment method class needs three core methods:

@AdjustmentRegistry.register("method-name")
class YourMethod(AdjustmentMethod):
    def required_model_parameters(self) -> Dict[str, List]:
        """Define expected configuration parameters"""
        pass

    def required_data_columns(self) -> List[str]:
        """Specify required data columns"""
        pass

    def adjust(self, data: pd.DataFrame, parameters: Dict[str, Any]) -> Dict[str, Any]:
        """Implement the adjustment logic"""
        pass

Return Format

The adjust method should return a dictionary with:

{
    "adjusted_data": pd.DataFrame,  # Your adjusted dataset
    "metrics": {                    # Method-specific metrics
        "metric1": value1,
        "metric2": value2
    }
}

Troubleshooting

Method Registration

If your method isn’t available:

# Check registration
from tact import TACT
tact = TACT()
print(tact.list_available_methods())  # Should include your method

Data Validation

Common data issues and solutions:

# Missing columns
required = self.required_data_columns()
missing = [col for col in required if col not in data.columns]
if missing:
    raise ValueError(f"Missing columns: {missing}")

# Invalid data types
if not pd.api.types.is_numeric_dtype(data["wind_speed"]):
    raise TypeError("Wind speed must be numeric")

Performance Issues

If your method is slow:

Use pandas vectorized operations
Pre-compute repeated values
Consider data preprocessing
Profile your code with cProfile

For more examples, see the SSSF and Baseline implementations.

Getting Started

Guides

Advanced

Add custom model

Overview

Creating Your Custom Model Package

Creating a Custom Model

Using Your Custom Model

Optional: Packaging Your Models

Implementation Guide

Class Structure

Return Format

Troubleshooting

Method Registration

Data Validation

Performance Issues

​Overview

​Creating Your Custom Model Package

​Creating a Custom Model

​Using Your Custom Model

​Optional: Packaging Your Models

​Implementation Guide

​Class Structure

​Return Format

​Troubleshooting

​Method Registration

​Data Validation

​Performance Issues

Overview

Creating Your Custom Model Package

Creating a Custom Model

Using Your Custom Model

Optional: Packaging Your Models

Implementation Guide

Class Structure

Return Format

Troubleshooting

Method Registration

Data Validation

Performance Issues