Poisson, Tweedie & Count Losses¶

← Censored Regression | Poisson-Gaussian →

Loss functions for count data, positive-continuous targets, and distributions with power mean-variance relationships.

See the count-loss API: PoissonDevianceLoss, TweedieLoss, NegativeBinomialNLLLoss, ZeroInflatedPoissonNLLLoss.

Mathematical Background¶

The Tweedie family unifies many common models through a single power-variance relationship:

Poisson Losses¶

PoissonDevianceLoss¶

The Poisson deviance (G-statistic) — measures goodness-of-fit for count data. See PoissonDevianceLoss API.

(half the classical G-statistic; matches PoissonDevianceLoss in code)

from torchregress.losses import PoissonDevianceLoss

loss_fn = PoissonDevianceLoss(log_input=True)  # model predicts log(λ)
loss = loss_fn(log_lambda, y_counts)

PoissonLikelihoodRatioLoss¶

Baker–Cousins likelihood ratio for binned data (PDG-standard):

from torchregress.losses import PoissonLikelihoodRatioLoss

loss_fn = PoissonLikelihoodRatioLoss(log_input=True)
loss = loss_fn(log_expected, observed_counts)

ZeroInflatedPoissonNLLLoss¶

For count data with excess zeros beyond what a standard Poisson would predict. See ZeroInflatedPoissonNLLLoss API.

from torchregress.losses import ZeroInflatedPoissonNLLLoss

loss_fn = ZeroInflatedPoissonNLLLoss(log_input=True)
# Model outputs [log(λ), logit(π)] concatenated
loss = loss_fn(model_output, y_counts)

NegativeBinomialNLLLoss¶

For overdispersed count data where \(\text{Var}(Y) > \mathbb{E}[Y]\). See NegativeBinomialNLLLoss API.

from torchregress.losses import NegativeBinomialNLLLoss

loss_fn = NegativeBinomialNLLLoss(learn_theta=True)  # learn dispersion
loss = loss_fn(y_pred_mean, y_counts)

Tweedie Losses¶

TweedieLoss¶

General-purpose Tweedie deviance for any power \(p\). See TweedieLoss API.

from torchregress.losses import TweedieLoss

# Compound Poisson-Gamma (zeros + positive continuous)
loss_fn = TweedieLoss(p=1.5, link="log")

# Model predicts log(μ)
loss = loss_fn(log_mu, y_target)

GammaLoss¶

Convenience class for \(p = 2\) (positive continuous targets with constant CV):

from torchregress.losses import GammaLoss

loss_fn = GammaLoss(link="log")

InverseGaussianLoss¶

For \(p = 3\) (highly right-skewed positive targets):

from torchregress.losses import InverseGaussianLoss

loss_fn = InverseGaussianLoss(link="log")

CompoundPoissonLoss¶

For \(1 < p < 2\) — handles data with a point mass at zero and positive continuous values:

from torchregress.losses import CompoundPoissonLoss

loss_fn = CompoundPoissonLoss(p=1.5, link="log")

Limitations¶

1. Compound Poisson numerical instability (\(1 < p < 2\)): The Tweedie density normalising constant involves an infinite series that converges slowly near the boundaries \(p \to 1\) (Poisson) and \(p \to 2\) (Gamma). Use PoissonDevianceLoss or GammaLoss for exactly \(p = 1\) or \(p = 2\).
2. Negative log-rate clipping: When log_input=True, large negative predicted log-rates produce near-zero rates \(\lambda = e^{\log\lambda}\), leading to \(\log(0)\) in deviance terms. Always clamp the minimum rate (min_rate) or use a small jitter.
3. Negative Binomial dispersion sensitivity: NegativeBinomialNLLLoss with \(\theta < 0.01\) produces extreme overdispersion with unstable gradients. Floor \(\theta\) with min_theta.
4. Tweedie power \(p\) is not learned: The power parameter \(p\) must be specified externally (e.g., from domain knowledge or a profile likelihood sweep). The loss does not optimise \(p\) jointly with the model.
5. Zero-inflated model identifiability: ZeroInflatedPoissonNLLLoss jointly estimates \(\pi\) (zero-inflation probability) and \(\lambda\) (rate). These parameters can trade off, especially with small datasets. Monitor both during training.

Decision Guide¶

graph TD
    A["Count / positive data?"] -->|Counts ∈ ℤ⁺| B{"Overdispersed?"}
    A -->|"Positive continuous"| C{"Zeros present?"}
    A -->|"Mixed: zeros + continuous"| D["CompoundPoissonLoss"]
    B -->|No| E["PoissonDevianceLoss"]
    B -->|"Var >> mean"| F["NegativeBinomialNLLLoss"]
    B -->|"Excess zeros"| G["ZeroInflatedPoissonNLLLoss"]
    C -->|No| H{"CV constant?"}
    C -->|Yes| D
    H -->|Yes| I["GammaLoss"]
    H -->|"Highly skewed"| J["InverseGaussianLoss"]

Complete Example¶

import torch
import torch.nn as nn
from torchregress.losses import TweedieLoss, NegativeBinomialNLLLoss

# Insurance claims: many zeros, occasional large payouts
class ClaimsModel(nn.Module):
    def __init__(self, in_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 1),
        )

    def forward(self, x):
        return self.net(x)  # predicts log(μ)

model = ClaimsModel(in_dim=20)
loss_fn = TweedieLoss(p=1.6, link="log")  # compound Poisson-Gamma
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

for x, y in train_loader:
    loss = loss_fn(model(x), y)
    optimizer.zero_grad(); loss.backward(); optimizer.step()

Next steps¶

• Poisson-Gaussian losses — combined shot noise + readout noise for imaging
• Robust losses — bounded-influence alternatives for tail-heavy data
• Transforms — log/Box-Cox alternatives for positive-skewed targets
• Count and Tweedie regression example — runnable demo (examples/count_regression_demo.py)

References¶