innovate 0.1.0__tar.gz

innovate-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: innovate
+Version: 0.1.0
+Summary: A Python library for simplifying innovation/policy diffusion modelling.
+Author-email: Your Name <your.email@example.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: statsmodels
+Provides-Extra: jax
+Requires-Dist: jax; extra == "jax"
+Requires-Dist: jaxopt; extra == "jax"
+Requires-Dist: diffrax; extra == "jax"
+
+# innovate
+
+A Python library for simplifying innovation/policy diffusion modelling.
+
+This library aims to provide a flexible and robust framework for modeling the diffusion of innovations and policies across various domains, from advanced health technologies (its origin in genetic and genomic testing) to marketing, economics, and policy research.
+
+## Core Features (Initial Release)
+
+*   **Diffusion Models**: Implementations of classic S-curve models like Gompertz, Logistic, and Bass (closed-form solutions).
+*   **Generic Competition-Diffusion Framework**: A flexible structure to model multi-product or multi-policy diffusion, allowing for intrinsic adoption rates, market sizes, and interaction matrices (within- and cross-imitation).
+*   **Data Handling**: Pandas-friendly API for time-series data with datetime indices.
+*   **Estimation**: Initial fitting capabilities using tried-and-true libraries like SciPy for nonlinear least squares.
+*   **Seasonality & Dispersion Handling**: Practical strategies for dealing with noisy, seasonal, or over-dispersed raw adoption data, including two-stage decomposition (e.g., using STL) and options for more integrated fitting approaches.
+
+## Roadmap
+
+The `innovate` library is designed for phased development, with a clear path towards advanced features and XLA-accelerated performance. See the [roadmap.md](roadmap.md) for detailed plans.
+
+## Installation
+
+More information coming soon!
+
+## Benchmarks
+
+Here are some initial benchmarks comparing the performance of the `ScipyFitter` (using the NumPy backend) and the `JaxFitter` (using the JAX backend).
+
+**Single Fit (100 samples, 1 dataset):**
+*   `ScipyFitter`: ~0.02s
+*   `JaxFitter`: ~5.7s
+
+**Batched Fit (100 samples, 10 datasets):**
+*   `BatchedFitter` (NumPy): ~0.06s
+*   `BatchedFitter` (JAX): ~15.5s
+
+**Note:** For small datasets, the `JaxFitter` is significantly slower than the `ScipyFitter` due to the overhead of JIT compilation. However, for larger datasets and in batched scenarios, the JAX backend is expected to be significantly faster. These benchmarks will be updated as the library evolves.
+
+## Usage
+
+Examples and tutorials will be provided to demonstrate how to use the library for various modeling scenarios.
+
+## License
+
+This project is licensed under the Apache 2.0 License.

innovate-0.1.0/README.md

@@ -0,0 +1,43 @@
+# innovate
+
+A Python library for simplifying innovation/policy diffusion modelling.
+
+This library aims to provide a flexible and robust framework for modeling the diffusion of innovations and policies across various domains, from advanced health technologies (its origin in genetic and genomic testing) to marketing, economics, and policy research.
+
+## Core Features (Initial Release)
+
+*   **Diffusion Models**: Implementations of classic S-curve models like Gompertz, Logistic, and Bass (closed-form solutions).
+*   **Generic Competition-Diffusion Framework**: A flexible structure to model multi-product or multi-policy diffusion, allowing for intrinsic adoption rates, market sizes, and interaction matrices (within- and cross-imitation).
+*   **Data Handling**: Pandas-friendly API for time-series data with datetime indices.
+*   **Estimation**: Initial fitting capabilities using tried-and-true libraries like SciPy for nonlinear least squares.
+*   **Seasonality & Dispersion Handling**: Practical strategies for dealing with noisy, seasonal, or over-dispersed raw adoption data, including two-stage decomposition (e.g., using STL) and options for more integrated fitting approaches.
+
+## Roadmap
+
+The `innovate` library is designed for phased development, with a clear path towards advanced features and XLA-accelerated performance. See the [roadmap.md](roadmap.md) for detailed plans.
+
+## Installation
+
+More information coming soon!
+
+## Benchmarks
+
+Here are some initial benchmarks comparing the performance of the `ScipyFitter` (using the NumPy backend) and the `JaxFitter` (using the JAX backend).
+
+**Single Fit (100 samples, 1 dataset):**
+*   `ScipyFitter`: ~0.02s
+*   `JaxFitter`: ~5.7s
+
+**Batched Fit (100 samples, 10 datasets):**
+*   `BatchedFitter` (NumPy): ~0.06s
+*   `BatchedFitter` (JAX): ~15.5s
+
+**Note:** For small datasets, the `JaxFitter` is significantly slower than the `ScipyFitter` due to the overhead of JIT compilation. However, for larger datasets and in batched scenarios, the JAX backend is expected to be significantly faster. These benchmarks will be updated as the library evolves.
+
+## Usage
+
+Examples and tutorials will be provided to demonstrate how to use the library for various modeling scenarios.
+
+## License
+
+This project is licensed under the Apache 2.0 License.

innovate-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "innovate"
+version = "0.1.0"
+description = "A Python library for simplifying innovation/policy diffusion modelling."
+authors = [
+    { name = "Your Name", email = "your.email@example.com" }
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "pandas",
+    "statsmodels"
+]
+requires-python = ">=3.8"
+readme = "README.md"
+license = "Apache-2.0"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "--import-mode=importlib"
+
+[project.optional-dependencies]
+jax = ["jax", "jaxopt", "diffrax"]

innovate-0.1.0/setup.cfg

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

innovate-0.1.0/src/innovate/backend.py

@@ -0,0 +1,34 @@
+from typing import Protocol, Type, Sequence, Dict
+from abc import ABC, abstractmethod
+
+# Define a type alias for array-like objects
+ArrayLike = Sequence[float]
+
+class Backend(Protocol):
+    def array(self, data: ArrayLike) -> ArrayLike: ...
+    def exp(self, x: ArrayLike) -> ArrayLike: ...
+    def power(self, base: ArrayLike, exp: ArrayLike) -> ArrayLike: ...
+    def solve_ode(self, f, y0: ArrayLike, t: ArrayLike) -> ArrayLike: ...
+    def stack(self, arrays: Sequence[ArrayLike]) -> ArrayLike: ...
+    def matmul(self, a: ArrayLike, b: ArrayLike) -> ArrayLike: ...
+    def zeros(self, shape: Sequence[int]) -> ArrayLike: ...
+    def sum(self, x: ArrayLike) -> float: ...
+    def mean(self, x: ArrayLike) -> float: ...
+    def where(self, condition: ArrayLike, x: ArrayLike, y: ArrayLike) -> ArrayLike: ...
+
+# Default backend (will be set to NumPyBackend initially)
+current_backend: Backend = None
+
+def use_backend(backend_name: str):
+    global current_backend
+    if backend_name == "numpy":
+        from .backends.numpy_backend import NumPyBackend
+        current_backend = NumPyBackend()
+    elif backend_name == "jax":
+        from .backends.jax_backend import JaxBackend
+        current_backend = JaxBackend()
+    else:
+        raise ValueError(f"Unknown backend: {backend_name}")
+
+# Initialize with NumPy backend by default
+use_backend("numpy")

innovate-0.1.0/src/innovate/backends/jax_backend.py

@@ -0,0 +1,44 @@
+import jax.numpy as jnp
+from diffrax import diffeqsolve, ODETerm, Tsit5
+from typing import Sequence
+
+class JaxBackend:
+    def array(self, data: Sequence[float]) -> jnp.ndarray:
+        return jnp.asarray(data)
+
+    def exp(self, x: jnp.ndarray) -> jnp.ndarray:
+        return jnp.exp(x)
+
+    def power(self, base: jnp.ndarray, exp: jnp.ndarray) -> jnp.ndarray:
+        return jnp.power(base, exp)
+
+    def solve_ode(self, f, y0: Sequence[float], t: Sequence[float]) -> jnp.ndarray:
+        term = ODETerm(f)
+        sol = diffeqsolve(term, Tsit5(), t[0], t[-1], t, y0)
+        return sol.ys
+
+    def stack(self, arrays: Sequence[jnp.ndarray]) -> jnp.ndarray:
+        return jnp.stack(arrays)
+
+    def matmul(self, a: jnp.ndarray, b: jnp.ndarray) -> jnp.ndarray:
+        return jnp.matmul(a, b)
+
+    def zeros(self, shape: Sequence[int]) -> jnp.ndarray:
+        return jnp.zeros(shape)
+
+    def sum(self, x: jnp.ndarray) -> float:
+        return jnp.sum(x)
+
+    def mean(self, x: jnp.ndarray) -> float:
+        return jnp.mean(x)
+
+    def where(self, condition: jnp.ndarray, x: jnp.ndarray, y: jnp.ndarray) -> jnp.ndarray:
+        return jnp.where(condition, x, y)
+
+    def jit(self, f):
+        from jax import jit
+        return jit(f)
+
+    def vmap(self, f):
+        from jax import vmap
+        return vmap(f)

innovate-0.1.0/src/innovate/backends/numpy_backend.py

@@ -0,0 +1,49 @@
+import numpy as np
+from scipy.integrate import odeint
+from typing import Sequence
+
+class NumPyBackend:
+    def array(self, data):
+        return np.asarray(data)
+    
+    exp = np.exp
+    power = np.power
+    def sum(self, a, axis=None, dtype=None, out=None, keepdims=False, initial=None, where=True):
+        return np.sum(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims, initial=initial, where=where)
+
+    def mean(self, a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
+        return np.mean(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims, where=where)
+    
+    def where(self, condition, x, y):
+        return np.where(condition, x, y)
+
+    def solve_ode(self, f, y0: Sequence[float], t: Sequence[float]) -> np.ndarray:
+        # scipy.integrate.odeint expects y0 as a 1D array and t as a 1D array
+        # The function f should take (y, t, *args) as arguments
+        # We need to adapt the signature of f if it expects (t, y, *args)
+        # For now, assuming f takes (y, t) as per common scipy usage
+        sol = odeint(f, y0, t)
+        return sol
+
+    def stack(self, arrays: Sequence[np.ndarray]) -> np.ndarray:
+        return np.stack(arrays)
+
+    def matmul(self, a: np.ndarray, b: np.ndarray) -> np.ndarray:
+        return np.matmul(a, b)
+
+    def zeros(self, shape: Sequence[int]) -> np.ndarray:
+        return np.zeros(shape)
+
+    def max(self, x: np.ndarray) -> float:
+        return np.max(x)
+
+    def median(self, x: np.ndarray) -> float:
+        return np.median(x)
+
+    def jit(self, f):
+        return f
+
+    def vmap(self, f):
+        def mapped_f(params, t_batched):
+            return np.array([f(p, t) for p, t in zip(params, t_batched)])
+        return mapped_f

innovate-0.1.0/src/innovate/fitters/batched_fitter.py

@@ -0,0 +1,55 @@
+from typing import Sequence, List
+from ..models.base import DiffusionModel
+from ..backend import current_backend as B
+
+class BatchedFitter:
+    """A fitter class for fitting a model to multiple datasets in a batch."""
+
+    def __init__(self, model: DiffusionModel, fitter):
+        self.model = model
+        self.fitter = fitter
+        self.fitted_params = None
+
+    def fit(self, t_batched: Sequence[Sequence[float]], y_batched: Sequence[Sequence[float]]):
+        """
+        Fits the model to a batch of datasets.
+
+        Args:
+            t_batched: A sequence of time sequences.
+            y_batched: A sequence of adoption sequences.
+        """
+        if len(t_batched) != len(y_batched):
+            raise ValueError("The number of time sequences and adoption sequences must be the same.")
+
+        params_list = []
+        for t, y in zip(t_batched, y_batched):
+            model_instance = type(self.model)()
+            self.fitter.fit(model_instance, t, y)
+            params_list.append(list(model_instance.params_.values()))
+        
+        self.fitted_params = B.array(params_list)
+        return self.fitted_params
+
+    def predict(self, t_batched: Sequence[Sequence[float]]):
+        """
+        Makes predictions for a batch of datasets.
+
+        Args:
+            t_batched: A sequence of time sequences.
+        """
+        if self.fitted_params is None:
+            raise RuntimeError("Model has not been fitted yet. Call .fit() first.")
+
+        def predict_single(params, t):
+            model_instance = type(self.model)()
+            # This is a bit of a hack, we should make this more generic
+            if model_instance.__class__.__name__ == "LogisticModel":
+                return model_instance._logistic_cumulative(t, params[0], params[1], params[2])
+            elif model_instance.__class__.__name__ == "BassModel":
+                return model_instance._bass_cumulative(t, params[0], params[1], params[2])
+            elif model_instance.__class__.__name__ == "GompertzModel":
+                return model_instance._gompertz_cumulative(t, params[0], params[1], params[2])
+
+
+        vmap_predict = B.vmap(predict_single)
+        return vmap_predict(self.fitted_params, B.array(t_batched))

innovate-0.1.0/src/innovate/fitters/bootstrap_fitter.py

@@ -0,0 +1,67 @@
+from typing import Sequence, Dict, List, Any
+import numpy as np
+from ..models.base import DiffusionModel
+
+class BootstrapFitter:
+    """A fitter class that uses bootstrapping to estimate parameter uncertainty."""
+
+    def __init__(self, n_bootstraps: int = 100):
+        self.n_bootstraps = n_bootstraps
+        self.bootstrapped_params: List[Dict[str, float]] = []
+
+    def fit(self, model: DiffusionModel, t: Sequence[float], y: Sequence[float]) -> None:
+        t_arr = np.array(t)
+        y_arr = np.array(y)
+        n_samples = len(t_arr)
+
+        for _ in range(self.n_bootstraps):
+            # Resample data with replacement
+            indices = np.random.choice(n_samples, n_samples, replace=True)
+            t_resampled = t_arr[indices]
+            y_resampled = y_arr[indices]
+
+            # Create a new model instance for each bootstrap iteration
+            # This is important to avoid parameter contamination between iterations
+            boot_model = type(model)()
+            
+            try:
+                boot_model.fit(t_resampled, y_resampled)
+                self.bootstrapped_params.append(boot_model.params_)
+            except RuntimeError as e:
+                # Handle cases where fitting might fail for a resampled dataset
+                print(f"Warning: Fitting failed for a bootstrap sample: {e}")
+                continue
+
+    def get_parameter_estimates(self) -> Dict[str, List[float]]:
+        """Returns a dictionary of parameter names to lists of bootstrapped values."""
+        if not self.bootstrapped_params:
+            return {}
+
+        # Assuming all models have the same parameter names
+        param_names = self.bootstrapped_params[0].keys()
+        estimates = {name: [] for name in param_names}
+
+        for params_dict in self.bootstrapped_params:
+            for name, value in params_dict.items():
+                estimates[name].append(value)
+        return estimates
+
+    def get_confidence_intervals(self, alpha: float = 0.05) -> Dict[str, Dict[str, float]]:
+        """Returns confidence intervals for each parameter."""
+        estimates = self.get_parameter_estimates()
+        cis = {}
+        for name, values in estimates.items():
+            if values:
+                lower = np.percentile(values, (alpha / 2) * 100)
+                upper = np.percentile(values, (1 - alpha / 2) * 100)
+                cis[name] = {"lower": float(lower), "upper": float(upper)}
+        return cis
+
+    def get_standard_errors(self) -> Dict[str, float]:
+        """Returns standard errors for each parameter."""
+        estimates = self.get_parameter_estimates()
+        ses = {}
+        for name, values in estimates.items():
+            if values:
+                ses[name] = float(np.std(values))
+        return ses

innovate-0.1.0/src/innovate/fitters/jax_fitter.py

@@ -0,0 +1,37 @@
+import jax
+import jax.numpy as jnp
+from jaxopt import LBFGS
+from typing import Sequence, Dict
+
+class JaxFitter:
+    """A fitter class that will use JAX for model estimation (Phase 2)."""
+
+    def fit(self, model, t: Sequence[float], y: Sequence[float], **kwargs) -> Dict[str, float]:
+        t_arr = jnp.asarray(t)
+        y_arr = jnp.asarray(y)
+
+        from heartflow.backend import current_backend, use_backend
+        original_backend = current_backend
+        use_backend("jax")
+
+        def _logistic_cumulative(t, L, k, x0):
+            from heartflow.backend import current_backend as B
+            return L / (1 + B.exp(-k * (t - x0)))
+        
+        model._logistic_cumulative = _logistic_cumulative
+
+        def loss_fn(params_array):
+            # Temporarily set model parameters for prediction within the loss function
+            predictions = model._logistic_cumulative(t_arr, params_array[0], params_array[1], params_array[2])
+            return jnp.sum((y_arr - predictions) ** 2)
+
+        initial_params = model._get_initial_params_as_array(t, y)
+
+        opt = LBFGS(fun=loss_fn, **kwargs)
+        sol = opt.run(init_params=initial_params)
+        
+        model._L, model._k, model._x0 = sol.params[0], sol.params[1], sol.params[2]
+
+        use_backend(original_backend.__class__.__name__.lower().replace('backend', '')) # Restore original backend
+
+        return model.params_

innovate-0.1.0/src/innovate/fitters/mom_fitter.py

@@ -0,0 +1,93 @@
+import numpy as np
+import pandas as pd
+from typing import Sequence, Tuple
+
+def estimate_bass_mom(t: Sequence[float], y: Sequence[float]) -> Tuple[float, float, float]:
+    """
+    Estimates the parameters (p, q, m) of the Bass Diffusion Model using the Method of Moments.
+    This implementation uses a linear regression approach based on incremental adoptions.
+
+    Args:
+        t: A sequence of time points.
+        y: A sequence of cumulative adoptions corresponding to the time points.
+
+    Returns:
+        A tuple (p, q, m) representing the estimated parameters.
+    """
+    if len(t) != len(y) or len(t) < 3:
+        raise ValueError("Input sequences t and y must have the same length and at least 3 data points.")
+
+    # Convert to pandas Series for easier manipulation
+    y_series = pd.Series(y, index=t)
+
+    # Calculate incremental adoptions (x_t)
+    # The first incremental adoption is y[0] if y starts from 0, or y[1]-y[0] if y[0] is the first cumulative.
+    # For simplicity, let's use diff() on the series.
+    incremental_adoptions = y_series.diff().fillna(y_series.iloc[0])
+
+    # Create lagged cumulative adoptions (y_{t-1})
+    lagged_cumulative_adoptions = y_series.shift(1).fillna(0)
+
+    # Prepare data for linear regression: x_t = a + b * y_{t-1} + c * y_{t-1}^2
+    # We need to exclude the first point where lagged_cumulative_adoptions is 0, as it's not a true lagged value.
+    data_for_reg = pd.DataFrame({
+        'x_t': incremental_adoptions,
+        'y_t_minus_1': lagged_cumulative_adoptions
+    })
+
+    # Remove the first row as y_t_minus_1 is 0 (or NaN if using dropna)
+    data_for_reg = data_for_reg.iloc[1:].dropna()
+
+    if len(data_for_reg) < 3:
+        raise ValueError("Not enough valid data points for Bass MoM estimation after preprocessing.")
+
+    X = pd.DataFrame({
+        'intercept': 1,
+        'y_t_minus_1': data_for_reg['y_t_minus_1'],
+        'y_t_minus_1_sq': data_for_reg['y_t_minus_1']**2
+    })
+    y_reg = data_for_reg['x_t']
+
+    try:
+        beta = np.linalg.lstsq(X, y_reg, rcond=None)[0]
+    except np.linalg.LinAlgError as e:
+        raise RuntimeError(f"Linear regression for Bass MoM failed: {e}. Check data for collinearity or insufficient variation.")
+
+    a, b, c = beta[0], beta[1], beta[2]
+
+    # Solve for p, q, m
+    # From x_t = a + b * y_{t-1} + c * y_{t-1}^2
+    # And Bass model incremental form: x_t = p*m + (q-p)*y_{t-1} - (q/m)*y_{t-1}^2
+    # Comparing coefficients:
+    # c = -q/m  => q = -c*m
+    # b = q - p
+    # a = p*m
+
+    # Rearrange to a quadratic equation for m: c*m^2 + b*m + a = 0
+    discriminant = b**2 - 4 * a * c
+
+    if discriminant < 0:
+        raise ValueError("Discriminant is negative, no real solution for m. Bass MoM estimation failed. Data might not fit Bass model assumptions well.")
+
+    m1 = (-b + np.sqrt(discriminant)) / (2 * c)
+    m2 = (-b - np.sqrt(discriminant)) / (2 * c)
+
+    # Choose the positive and meaningful m (market potential should be positive)
+    # And m should be greater than or equal to the maximum observed cumulative adoption.
+    m_candidates = [val for val in [m1, m2] if val > 0 and val >= np.max(y)]
+
+    if not m_candidates:
+        raise ValueError("No valid positive market potential (m) found that is greater than or equal to max observed adoption. Bass MoM estimation failed.")
+    
+    # If there are two valid candidates, typically the larger one is chosen for m.
+    m = max(m_candidates)
+
+    # Calculate q and p
+    q = -c * m
+    p = a / m
+
+    # Ensure p and q are positive, as per Bass model assumptions
+    if p <= 0 or q <= 0:
+        raise ValueError(f"Estimated p ({p}) or q ({q}) is not positive. Bass MoM estimation failed. Data might not fit Bass model assumptions well.")
+
+    return p, q, m

innovate-0.1.0/src/innovate/fitters/scipy_fitter.py

@@ -0,0 +1,86 @@
+from typing import Sequence, Dict, Callable, Any, Self
+import numpy as np
+from scipy.optimize import curve_fit
+from ..models.base import DiffusionModel
+from ..models.competition import MultiProductDiffusionModel
+
+class ScipyFitter:
+    """A fitter class that uses SciPy's curve_fit for model estimation."""
+
+    def __init__(self):
+        self.params_: Dict[str, float] = None
+
+    def fit(self, model: DiffusionModel, t: Sequence[float], y: Sequence[float], **kwargs) -> Self:
+        """
+        Fits a DiffusionModel instance using scipy.optimize.curve_fit.
+
+        Args:
+            model: An instance of a DiffusionModel (e.g., BassModel, GompertzModel, LogisticModel).
+            t: Time points (independent variable).
+            y: Observed adoption data (dependent variable).
+            kwargs: Additional keyword arguments to pass to scipy.optimize.curve_fit.
+
+        Returns:
+            A dictionary of the fitted parameters.
+        
+        Raises:
+            RuntimeError: If fitting fails.
+        """
+        
+        t_arr = np.array(t)
+        y_arr = np.array(y)
+
+        # For MultiProductDiffusionModel, y will be a flattened array of multiple products
+        # We need to handle this by reshaping the prediction from the model.
+        if isinstance(model, MultiProductDiffusionModel):
+            # The objective function for curve_fit needs to take t and then the parameters
+            # and return a flattened array of predictions for all products.
+            
+            # We need to define the parameters to be fitted for MultiProductDiffusionModel.
+            # For now, let's assume we are fitting p, Q, m. This will require careful
+            # flattening and unflattening of parameters.
+            
+            # This is a more complex scenario for curve_fit. A custom optimization routine
+            # might be more suitable for MultiProductDiffusionModel.
+            
+            # For Phase 1, we will only support fitting of single-product models (Bass, Gompertz, Logistic)
+            # with curve_fit directly. MultiProductDiffusionModel will be fitted by manually
+            # setting parameters or with a more advanced fitter in later phases.
+            
+            raise NotImplementedError("Fitting MultiProductDiffusionModel with ScipyFitter is not yet implemented. "
+                                      "Please use single-product models for now or manually set parameters for MultiProductDiffusionModel.")
+
+        # For single-product models, we can use the model's predict method as the curve_fit function
+        # The predict method expects (t, *params) if it's a static function, 
+        # but here it's a method that uses internal state.
+        # So, we need a wrapper function that takes parameters as arguments.
+        
+        # The model's _bass_cumulative, _gompertz_cumulative, _logistic_cumulative are suitable.
+        # We need to get the initial guesses and bounds from the model itself or provide them here.
+        
+        # This requires a slight modification to how curve_fit is used with the DiffusionModel interface.
+        # The DiffusionModel.fit() method already handles curve_fit internally for single models.
+        # So, this ScipyFitter will primarily be used for more complex fitting scenarios or 
+        # to provide a unified interface for different optimization backends.
+        
+        # For Phase 1, the single-product models (Bass, Gompertz, Logistic) already have their
+        # own `fit` methods that use `curve_fit`. This `ScipyFitter` class will be more relevant
+        # when we introduce a generic `fit` method that can take any `DiffusionModel` and optimize it.
+        
+        # Let's make this fitter work by calling the model's internal curve_fit logic
+        # or by providing a generic way to get the curve function and initial parameters.
+        
+        # For now, this fitter will simply call the model's `fit` method.
+        # This makes the `ScipyFitter` a thin wrapper for Phase 1.
+        
+        # In future phases, this `ScipyFitter` will contain the actual optimization logic
+        # for various models, including MultiProductDiffusionModel.
+        
+        # Ensure the model has a fit method that accepts t and y
+        if not hasattr(model, 'fit') or not callable(model.fit):
+            raise AttributeError("Model must have a 'fit' method.")
+        
+        # Call the model's own fit method
+        fitted_model = model.fit(t, y)
+        self.params_ = fitted_model.params_
+        return self

innovate-0.1.0/src/innovate/models/base.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Sequence, TypeVar
+
+# Define a type variable for the class itself, for type hinting Self
+Self = TypeVar('Self')
+
+class DiffusionModel(ABC):
+    """Abstract base class for all diffusion models."""
+
+    @abstractmethod
+    def fit(self, t: Sequence[float], y: Sequence[float]) -> Self:
+        """Fits the diffusion model to the given time and adoption data."""
+        pass
+
+    @abstractmethod
+    def predict(self, t: Sequence[float]) -> Sequence[float]:
+        """Predicts adoption levels for given time points."""
+        pass
+
+    @abstractmethod
+    def score(self, t: Sequence[float], y: Sequence[float]) -> float:
+        """Returns the R^2 score of the model fit."""
+        pass
+
+    @property
+    @abstractmethod
+    def params_(self) -> Dict[str, float]:
+        """Returns a dictionary of fitted model parameters."""
+        pass
+
+    @abstractmethod
+    def predict_adoption_rate(self, t: Sequence[float]) -> Sequence[float]:
+        """Predicts the rate of adoption (new adoptions per unit of time)."""
+        pass