Targets

Use this page to choose a target class, understand the convention each class must follow, or see what columns each class adds.

How Targets Fit In The Pipeline

The manifest pipeline is split-first:

1. fetch and prepare raw data
2. split into train, validation, and test
3. apply indicators and features
4. fit the target class on the training split
5. apply the fitted instance to all splits using the stored state

This ensures that any statistics derived from the training data (such as quantile cutoffs) do not leak into validation or test.

One outcome, one preparation boundary

The Python project predicts next-bar open-to-close return. Its preparation function runs separately inside each split. The negative shift creates the future outcome used for fitting and validation; that outcome is excluded from inference features.

1def prepare_split(bars, round_params):2    return features(bars, round_params["window"]).with_columns(3        (pl.col("close").shift(-1) / pl.col("open").shift(-1) - 1)4        .alias("next_return")5    ).slice(12).drop_nulls(["momentum", "next_return"])

The Compiled project predicts whether the next momentum observation exceeds a training-fitted quantile. Its Manifest declares the class and the constructor and transform arguments:

1    target:2      name: quantile_flag3      class: limen.targets.QuantileBinaryTarget4      fit_params:5        source_column: roc_16        quantile: 0.57      transform_params:8        shift: -1

fit_params go to the target constructor on the training split; transform_params go to transform() on each split. Values can refer to declared round parameters. Compiled Research declares these values in YAML. Python Research can call the same target classes directly, provided its preparation owns the fitting and split boundaries.

The reference below gives current package signatures and the behavior of each alternative. Constructor and transform signatures describe the API; they do not claim that every target participates in the two selection runs. Data-dependent targets still require their stated columns, fitting observations and execution economics.

Choosing A Target Class

Candidate target perturbations

ForwardBreakoutTarget.transform accepts horizon_jitter, threshold_noise_std, noise_seed and label_smoothing. TripleBarrierTarget.transform accepts horizon_jitter, barrier_noise_std and noise_seed. All default to zero, retaining the original target calculation.

Jitter is drawn once per candidate and reused across its partitions. A SHA-256 seed over the limen-target-perturbation-v1 namespace, complete permutation ID and explicit noise_seed initializes NumPy's generator. The horizon receives a uniform integer offset in the inclusive jitter range; every possible horizon must remain positive. Thresholds/barrier multiples receive independent multiplicative Gaussian draws base * (1 + Normal(0, std)). Nonpositive or nonfinite realized thresholds raise errors. The fitted target retains perturbation_parameters, including the realized horizon, thresholds and identity.

UEL, parallel workers and Trainer/fold reconstruction supply the logged candidate ID automatically, including runs with context parameters. permutation_id and training are reserved framework operands in manifest/YAML transforms. Direct target calls must provide an ID when enabling noise; direct manifest preparation derives an identity from its supplied parameters. Declare the noise controls through ordinary target transform_params references so their values and seeds remain in the round log. Enabled permutation-seeded noise is refused by factorize=True, whose cross-candidate reuse would otherwise change its meaning.

Binary label smoothing applies (1 - alpha) * y + alpha / 2 only to the training partition, with 0 <= alpha < 1. Validation and test labels remain hard. The model must accept continuous training targets; native hard-label classifiers reject them through their normal model validation. The recorded proof uses DLinear for serial/parallel and ordinary Trainer execution, and Ridge for selected-fold reconstruction. It checks unchanged evaluation labels, Python/CLI execution and candidate identity throughout.

The recorded proofs are tests/test_target_perturbations.py; they also compare noisy targets directly against the original calculation under their realized parameters.

Reference

QuantileBinaryTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, source_column: str, quantile: float) -> None:2    ...

Fits a quantile cutoff on the training split. Labels a bar as positive if the source column exceeds the (1 - quantile) quantile of the training distribution.

1def transform(self, data: pl.DataFrame, shift: int=0) -> pl.DataFrame:2    ...

TradelineLongBinaryTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, max_duration_hours: int, min_height_pct: float, long_threshold_percentile: float) -> None:2    ...

Fits the breakout threshold on the training split: detects price lines on close (limen.utils.find_price_lines) and stores the long_threshold_percentile percentile of long-line heights. Raises when the training split yields no long lines. The transform labels a bar 1 when the maximum close over [t, t + lookahead_hours] reaches the threshold AND the point return at +confirmation_hours or at +lookahead_hours also exceeds it — the move must stick, not just spike. Rows without a full forward window become null and fall to the pipeline's drop_nulls.

1def transform(self, data: pl.DataFrame, lookahead_hours: int=DEFAULT_LOOKAHEAD_HOURS, confirmation_hours: int=DEFAULT_CONFIRMATION_HOURS) -> pl.DataFrame:2    ...

ThresholdBinaryTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, source_column: str, threshold: float) -> None:2    ...

Labels a bar as positive if the source column exceeds a fixed threshold. No fitting step — the threshold is specified directly.

1def transform(self, data: pl.DataFrame, shift: int=-1) -> pl.DataFrame:2    ...

ForwardBreakoutTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Labels a bar as positive if the close price rises by at least threshold over the next forward_periods bars. No fitting step.

1def transform(self, data: pl.DataFrame, forward_periods: int=24, threshold: float=0.02, shift: int=-1, *, horizon_jitter: int=0, threshold_noise_std: float=0.0, noise_seed: int=0, label_smoothing: float=0.0, permutation_id: str | None=None, training: bool=False) -> pl.DataFrame:2    ...

EmaBreakoutTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Labels a bar as positive if the price breakout_horizon bars ahead exceeds the EMA of target_col by at least breakout_delta. No fitting step.

1def transform(self, data: pl.DataFrame, target_col: str='close', ema_span: int=30, breakout_delta: float=0.2, breakout_horizon: int=3) -> pl.DataFrame:2    ...

NextReturnTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Produces a continuous target as the percentage return over the next N bars. Use with regression architectures such as xgboost_regressor. No fitting step.

1def transform(self, data: pl.DataFrame, periods: int=1, scale: float=100.0) -> pl.DataFrame:2    ...

NextBarUpTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Produces a binary target named next_bar_up: 1 when the next close is higher than the current close, 0 otherwise. The final row in each split has no next bar, so it is null and is dropped by manifest preparation.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

No parameters.

NextBarDownTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Produces a binary target named next_bar_down: 1 when the next close is lower than the current close, 0 otherwise. The final row in each split has no next bar, so it is null and is dropped by manifest preparation.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

No parameters.

VolNormalizedReturnTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, high_col: str='high', low_col: str='low', open_col: str='open', close_col: str='close', halflife: int=50, min_periods: int=150) -> None:2    ...

Produces a continuous target named vol_normalized_return. The target is log(close / close.shift(1)) / sigma.shift(1), where sigma is the EWMA Parkinson volatility from (log(high / low) ** 2) / (4 * ln(2)). The one-bar sigma shift prevents the current bar range from entering the current return label.

Dirty OHLC rows are dropped before target construction when high < max(open, close) or low > min(open, close). Zero volatility is converted to null, not epsilon.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

The training split must pass the Parkinson-to-close volatility sanity gate: median sigma_P / sigma_C2C must be within [0.9, 1.1]. Bucketing is deliberately downstream: fit q33/q66 of abs(vol_normalized_return) on train, persist the boundaries, and load them at inference instead of refitting online.

ForwardVolNormalizedReturnTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, periods: int=1, absolute: bool=False, halflife: int=50, min_periods: int=150, high_col: str='high', low_col: str='low', open_col: str='open', close_col: str='close') -> None:2    ...

Produces a continuous predictive label as log(close.shift(-periods) / close) / sigma, where sigma is the current EWMA Parkinson volatility. Set absolute=True to normalize absolute forward movement instead of signed direction.

1@override2def transform(self, data: pl.DataFrame) -> pl.DataFrame:3    ...

The class reuses the same dirty-bar filter and Parkinson-to-close volatility sanity gate as VolNormalizedReturnTarget.

TripleBarrierTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, upper_multiple: float=1.0, lower_multiple: float=1.0, max_horizon: int=10, span: int=100, min_periods: int=100, close_col: str='close') -> None:2    ...

Produces a ternary label from Lopez de Prado's triple-barrier method. For each bar, the forward close path is followed for up to max_horizon bars and labelled by the first barrier it touches: 1 if the upper (profit-taking) barrier is touched first, -1 if the lower (stop-loss) barrier is touched first, and 0 if neither is touched within max_horizon bars (the vertical barrier). No fitting step.

The horizontal barriers are volatility multiples — +upper_multiple * sigma and -lower_multiple * sigma, where sigma is the EWMA standard deviation of close-to-close returns with the given span. The barrier width is taken from the entry-bar volatility, so it adapts to the local regime instead of using a fixed percentage.

A bar is null during the volatility warmup (min_periods), when its volatility is zero, and when the vertical barrier would extend past the available data and no barrier is touched within the truncated window. Manifest preparation drops null target rows. Size min_periods (and span) against the smallest split: a split shorter than the volatility warmup is entirely null and is dropped, leaving no labelled rows for that split.

1def transform(self, data: pl.DataFrame, *, horizon_jitter: int=0, barrier_noise_std: float=0.0, noise_seed: int=0, permutation_id: str | None=None, training: bool=False) -> pl.DataFrame:2    ...

RiskRewardRatioTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Computes capturable_breakout / (|max_drawdown| + 0.001) per row. Expects both columns to be available on every split. No fitting step. No Limen indicator or feature produces capturable_breakout or max_drawdown — they must be user-supplied in the input data, and transform raises ValueError when they are absent.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

No parameters.

ExitQualityTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Scores closed trades as high, low, or medium based on exit_reason and exit_net_return. Expects both columns to be available on every split. No fitting step. No Limen indicator or feature produces exit_reason or exit_net_return — they must be user-supplied in the input data, and transform raises ValueError when they are absent.

1def transform(self, data: pl.DataFrame, exit_quality_high: float=1.0, exit_quality_low: float=0.2, exit_quality_medium: float=0.5) -> pl.DataFrame:2    ...

RandomBinaryTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str, random_state: int | None=None) -> None:2    ...

Produces uniformly random binary labels. No fitting step. Use as a noise benchmark to verify that a trained model outperforms chance.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

random_state is optional. Pass an integer for reproducible labels across equal split sizes and call order; None uses an unseeded generator.

IdentityTarget

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

For when the target column is already present in the data. Validates that the column exists on the training split and on every subsequent split. The data is returned unchanged; no new column is added.

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

No parameters.

Simulated Trade Outcomes

TradeOutcomeTarget requires configured execution economics and a linear perpetual product supporting both sides. The manifest injects TradeTargetContext into construction and every transform; callers do not build it during normal manifest use.

1def __init__(self, train_data: pl.DataFrame, target_name: str, *, trade_context: TradeTargetContext, side: Literal['long', 'short']='long', output: Literal['binary', 'net_return']='binary', candidate_exposure: float=1.0) -> None:2    ...

1def transform(self, data: pl.DataFrame, *, trade_context: TradeTargetContext, **transform_params: object) -> pl.DataFrame:2    ...

Each feature-valid bar starts independent long and short candidates with fixed candidate exposure. Entry, TP/SL, elapsed exits, costs, rounding and funding use the shared execution contract. Returns equal completed net PnL divided by pre-entry equity; binary output is strictly positive return. Zero is unprofitable. At least one exit rule is required.

Only observations within the true split can complete a candidate. A completed late trade remains eligible even after an earlier unfinished candidate. An unfinished outcome is null, with a private availability mask and completion timestamp. Those masks select fitting and metric rows; they never remove otherwise valid inference rows. Warm-up rows outside a split receive no outcome.

The long/short returns, masks and exit times live in _trade_labels: OutcomeLabels, bound to the execution contracts. They never enter feature selection, scaling, PCA or Sensor inputs. The public target column contains only the requested side/output. Architectures consuming these targets must explicitly support private availability masks; direction/sizing provides that integration.

Unknown target parameters, mismatched contracts and missing economics fail before fitting.

Writing A Custom Target Class

A custom target accepts training data and the target column name at construction, then exposes transform(data, **transform_params). Fit any learned state in the constructor and reuse it in transform. NextBarUpTarget gives the minimal concrete package interface:

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

There is no base class to inherit from — the convention is enforced structurally, the same way scalers work. Any class that accepts (train_data, target_name, **fit_params) in __init__ and exposes transform(data, **transform_params) -> pl.DataFrame is a valid target class.

source_columns is optional on the target class or fitted instance. Declare a list of column names consumed to build labels that must not become features. Manifest preparation removes any declared columns still present after transform(), before scaling and feature extraction, on all three splits and fitted-target replay. ML and native rule Sensor preparation apply declared exclusions from fitted target metadata before deciding feature availability, without recomputing labels or fitting the target. ML scaling and PCA then retain their existing order. Missing or empty declarations exclude no live columns; undeclared drops or mutations inside transform() are not replayed at inference. Rule Sensor preparation requires the fitted target instance and raises if it is missing.

A declaration must be a list of strings and must not include target_name. Invalid declarations raise TypeError; excluding the target raises ValueError. Other columns, values and retained row order remain unchanged. The declaration excludes only named inputs; it does not automatically detect look-ahead features.

ExitQualityTarget declares exit_reason and exit_net_return; RiskRewardRatioTarget declares capturable_breakout and max_drawdown. Their directly called transform() methods retain their existing column removal. Custom targets may keep their own removal during research or rely on manifest enforcement; declare those source columns to exclude them during live preparation. Columns already removed by a research target are accepted.

Read Next

• Experiment Manifest for how targets plug into the split-first pipeline
• Scalers for train-fitted preprocessing that runs after target construction
• Transforms for stateless post-model helpers

Meta allocation retains the primary target. Forward QuantileBinaryTarget fitting is rebuilt inside each chronological prefix; prediction-block membership is feature-valid and includes the tail without completed forward targets. Allocator supervision is separate: signed net PnL divided by the first actual entry fill notional, available only after real closure inside the opening training block. Open, unfilled and crossing opportunities remain unavailable; they are not zero-return training examples. See Backtest.

Recorded target variants

The Python project retains separate train/validation/test label frames in search/targets/. Its raw-bar cases also preserve a data-dependent volatility sanity refusal and the required-column errors for trade-context labels. Supplied outcome columns are exercised separately rather than invented inside a target.

The Compiled project runs target_*.yaml through the installed CLI. Each class uses a compatible classifier or regressor. Volatility gate outcomes remain explicit. The derived label files contain declared software outcomes from recorded closes, with no future window crossing a chronological partition; they are not venue execution observations. Allocation manifests exercise the native trade-outcome target and bound event context.

Callable contracts

These entries give the exact public signatures and the source-owned argument, return and failure contracts. Use the project examples above for the research context; a signature is reference evidence, not a claim that every option ran in the base experiment.

limen.targets.EmaBreakoutTarget

1class EmaBreakoutTarget:2    ...

Binary target flagging forward price breakouts above an EMA threshold.

limen.targets.EmaBreakoutTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.EmaBreakoutTarget.transform

1def transform(self, data: pl.DataFrame, target_col: str='close', ema_span: int=30, breakout_delta: float=0.2, breakout_horizon: int=3) -> pl.DataFrame:2    ...

Label 1 when the price breakout_horizon bars ahead exceeds the EMA

of target_col by at least breakout_delta of the EMA value.

Returns: pl.DataFrame: Data with target column added

limen.targets.ExitQualityTarget

1class ExitQualityTarget:2    source_columns: ClassVar[list[str]] = list(_REQUIRED_COLUMNS)

Categorical target scoring trade exits by reason and net return.

limen.targets.ExitQualityTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.ExitQualityTarget.transform

1def transform(self, data: pl.DataFrame, exit_quality_high: float=1.0, exit_quality_low: float=0.2, exit_quality_medium: float=0.5) -> pl.DataFrame:2    ...

Score each closed trade as high, low, or medium quality based on its

exit_reason and exit_net_return.

Returns: pl.DataFrame: Data with target column added

Raises: ValueError: If the required user-supplied columns are absent

limen.targets.ForwardBreakoutTarget

1class ForwardBreakoutTarget:2    ...

Binary target for forward price breakouts above a percentage threshold.

limen.targets.ForwardBreakoutTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.ForwardBreakoutTarget.transform

1def transform(self, data: pl.DataFrame, forward_periods: int=24, threshold: float=0.02, shift: int=-1, *, horizon_jitter: int=0, threshold_noise_std: float=0.0, noise_seed: int=0, label_smoothing: float=0.0, permutation_id: str | None=None, training: bool=False) -> pl.DataFrame:2    ...

Label 1 if price rises >= threshold over next forward_periods bars.

Returns: pl.DataFrame: Data with target column added

limen.targets.ForwardVolNormalizedReturnTarget

1class ForwardVolNormalizedReturnTarget(VolNormalizedReturnTarget):2    ...

Forward log return normalized by current Parkinson volatility.

limen.targets.ForwardVolNormalizedReturnTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, periods: int=1, absolute: bool=False, halflife: int=50, min_periods: int=150, high_col: str='high', low_col: str='low', open_col: str='open', close_col: str='close') -> None:2    ...

Store target settings and validate Parkinson volatility on train.

limen.targets.ForwardVolNormalizedReturnTarget.transform

1@override2def transform(self, data: pl.DataFrame) -> pl.DataFrame:3    ...

Compute log(close.shift(-periods) / close) / parkinson_sigma.

Returns: pl.DataFrame: Cleaned data with target column added

limen.targets.IdentityTarget

1class IdentityTarget:2    ...

Target class for columns already present in the data.

limen.targets.IdentityTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Validate the target column exists; no fitting is performed.

limen.targets.IdentityTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Return data unchanged after validating the target column is present.

Returns: pl.DataFrame: Data unchanged

limen.targets.NextBarDownTarget

1class NextBarDownTarget:2    ...

Binary target for whether the next close is below the current close.

limen.targets.NextBarDownTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.NextBarDownTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Label 1 if the next close is lower than the current close.

Returns: pl.DataFrame: Data with target column added

limen.targets.NextBarUpTarget

1class NextBarUpTarget:2    ...

Binary target for whether the next close is above the current close.

limen.targets.NextBarUpTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.NextBarUpTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Label 1 if the next close is higher than the current close.

Returns: pl.DataFrame: Data with target column added

limen.targets.NextReturnTarget

1class NextReturnTarget:2    ...

Continuous target as next-period percentage return on close price.

limen.targets.NextReturnTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.NextReturnTarget.transform

1def transform(self, data: pl.DataFrame, periods: int=1, scale: float=100.0) -> pl.DataFrame:2    ...

Compute percentage return over the next N periods.

Returns: pl.DataFrame: Data with target column added

limen.targets.OutcomeLabels

1@dataclass(frozen=True)2class OutcomeLabels:3    rows: pl.DataFrame4    contract_digest: str

limen.targets.QuantileBinaryTarget

1class QuantileBinaryTarget:2    ...

Binary target label from training-set quantile cutoff.

limen.targets.QuantileBinaryTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, source_column: str, quantile: float) -> None:2    ...

Fit quantile cutoff on training data.

limen.targets.QuantileBinaryTarget.transform

1def transform(self, data: pl.DataFrame, shift: int=0) -> pl.DataFrame:2    ...

Apply binary flag and optional temporal shift.

Returns: pl.DataFrame: Data with target column added

limen.targets.RandomBinaryTarget

1class RandomBinaryTarget:2    ...

Uniformly random binary target, used as a noise benchmark.

limen.targets.RandomBinaryTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, random_state: int | None=None) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.RandomBinaryTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Apply random binary labels.

Returns: pl.DataFrame: Data with target column added

limen.targets.RiskRewardRatioTarget

1class RiskRewardRatioTarget:2    source_columns: ClassVar[list[str]] = list(_REQUIRED_COLUMNS)

Continuous target as the ratio of capturable breakout to absolute drawdown.

limen.targets.RiskRewardRatioTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str) -> None:2    ...

Store the target column name; no fitting is performed.

limen.targets.RiskRewardRatioTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Compute capturable_breakout / (\|max_drawdown\| + EPSILON) per row.

Returns: pl.DataFrame: Data with target column added

Raises: ValueError: If the required user-supplied columns are absent

limen.targets.ThresholdBinaryTarget

1class ThresholdBinaryTarget:2    ...

Binary target from a fixed threshold comparison on a source column.

limen.targets.ThresholdBinaryTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, source_column: str, threshold: float) -> None:2    ...

Store the fixed threshold; no fitting is performed.

limen.targets.ThresholdBinaryTarget.transform

1def transform(self, data: pl.DataFrame, shift: int=-1) -> pl.DataFrame:2    ...

Apply binary flag and optional temporal shift.

Returns: pl.DataFrame: Data with target column added

limen.targets.TradeOutcomeTarget

1class TradeOutcomeTarget:2    requires_trade_context: ClassVar[bool] = True

limen.targets.TradeOutcomeTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, *, trade_context: TradeTargetContext, side: Literal['long', 'short']='long', output: Literal['binary', 'net_return']='binary', candidate_exposure: float=1.0) -> None:2    ...

limen.targets.TradeOutcomeTarget.outcomes

1@property2def outcomes(self) -> OutcomeLabels:3    ...

limen.targets.TradeOutcomeTarget.transform

1def transform(self, data: pl.DataFrame, *, trade_context: TradeTargetContext, **transform_params: object) -> pl.DataFrame:2    ...

limen.targets.TradeTargetContext

1@dataclass(frozen=True)2class TradeTargetContext:3    policy: TradePolicy4    inputs: TradeInputs5    partition_start_ns: int6    partition_end_ns: int7    contract_digest: str

limen.targets.TradelineLongBinaryTarget

1class TradelineLongBinaryTarget:2    ...

Binary long target from a train-fitted line-height percentile threshold.

limen.targets.TradelineLongBinaryTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, max_duration_hours: int, min_height_pct: float, long_threshold_percentile: float) -> None:2    ...

Fit the breakout threshold from long lines detected on the training split.

Raises: ValueError: If 'close' is missing, the percentile is outside [0, 100],

or no long lines exist in the training split

limen.targets.TradelineLongBinaryTarget.transform

1def transform(self, data: pl.DataFrame, lookahead_hours: int=DEFAULT_LOOKAHEAD_HOURS, confirmation_hours: int=DEFAULT_CONFIRMATION_HOURS) -> pl.DataFrame:2    ...

Apply the confirmed-breakout label using the fitted threshold.

Label 1 where the maximum close over [t, t + lookahead_hours] reaches

the threshold AND the point return at +confirmation_hours or at

+lookahead_hours also exceeds it; 0 otherwise. Rows without a full

forward window become null.

Returns: pl.DataFrame: Data with the target column added

Raises: ValueError: If 'close' is missing, a window is below 1, or

confirmation_hours exceeds lookahead_hours

limen.targets.TripleBarrierTarget

1class TripleBarrierTarget:2    ...

Ternary label from Lopez de Prado's triple-barrier method.

limen.targets.TripleBarrierTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, upper_multiple: float=1.0, lower_multiple: float=1.0, max_horizon: int=10, span: int=100, min_periods: int=100, close_col: str='close') -> None:2    ...

Store barrier settings and validate them; no fitting is performed.

limen.targets.TripleBarrierTarget.transform

1def transform(self, data: pl.DataFrame, *, horizon_jitter: int=0, barrier_noise_std: float=0.0, noise_seed: int=0, permutation_id: str | None=None, training: bool=False) -> pl.DataFrame:2    ...

Label each bar by the first barrier its forward close path touches.

Returns: pl.DataFrame: Data with a ternary target column added (1 upper, -1 lower,

0 vertical; null during volatility warmup and when the vertical barrier

extends past the available data)

limen.targets.VolNormalizedReturnTarget

1class VolNormalizedReturnTarget:2    ...

Continuous target as log return normalized by prior Parkinson volatility.

limen.targets.VolNormalizedReturnTarget.__init__

1def __init__(self, train_data: pl.DataFrame, target_name: str, high_col: str='high', low_col: str='low', open_col: str='open', close_col: str='close', halflife: int=50, min_periods: int=150) -> None:2    ...

Store target settings and validate Parkinson against close-to-close volatility on train.

limen.targets.VolNormalizedReturnTarget.transform

1def transform(self, data: pl.DataFrame) -> pl.DataFrame:2    ...

Compute log(close / close.shift(1)) / parkinson_sigma.shift(1).

Returns: pl.DataFrame: Cleaned data with target column added