Swing Trading: Optimize Extrema For Better Profits

Dec 15, 2025 by Alex Johnson 51 views

Hey there, fellow traders! Let's dive deep into a topic that's been causing a bit of a headache in our recent Ver3 sessions: **swing detection**, specifically when it comes to picking the *perfect* high or low point for our trades. It turns out, about 75% of our false positives (FPs) are stemming from what we call **endpoint selection issues**. This means our detector is brilliant at identifying a potential swing – a price move up or down – but it's sometimes grabbing a slightly off high or low point. We're talking about the difference between a good entry and a *great* one, and in trading, that can make all the difference to your bottom line. This article is all about tackling these **suboptimal extremas** head-on, making your swing detection more robust and, ultimately, more profitable. We'll explore a new technique designed to refine these endpoints, ensuring you capture the true highs and lows that define a significant market move.

The Problem: Suboptimal Swing Endpoints

In the fast-paced world of swing trading, timing is everything. We rely on sophisticated detectors to pinpoint potential opportunities, identifying significant price swings that suggest a trend is forming or reversing. However, our current system, while effective at identifying the *existence* of a swing, often settles for the first valid extremum it encounters. Imagine spotting a mountain range – our detector sees the general shape, but it might be picking a foothill instead of the actual summit or the deepest valley. This isn't just a minor quibble; when we're talking about 75% of our false positives, it's a significant hurdle to overcome. The core issue is that often, a 'better' extremum – a true highest high or a definitive lowest low – exists nearby, just a few bars away. These subtle differences in endpoint selection can lead to trades that start off with less favorable pricing, reducing potential profit margins or even increasing risk. We need a way to refine these initial picks, ensuring that when our detector flags a swing, it's anchored to the most significant price extreme within that move. This refinement is crucial for improving the accuracy of our trading signals and reducing the noise that can lead to costly mistakes. Without this, we're essentially leaving potential profits on the table and opening ourselves up to unnecessary risks by acting on imperfect data. The goal is to move beyond simply identifying a swing to precisely defining its boundaries with the most impactful price points.

The Solution: Introducing Best Extrema Adjustment

To combat the issue of suboptimal swing endpoints, we're introducing a powerful new step to our analysis pipeline: **Best Extrema Adjustment**. This isn't about changing how we detect swings initially, but rather about refining the endpoints *after* a swing has been identified and paired, but *before* we commit to its validity through protection checks. Think of it as a post-processing polish. Once we've got a potential swing candidate, we'll take a closer look at the immediate vicinity of its identified high and low points. The goal is simple: find the *actual* highest high and the *actual* lowest low within a specified 'lookback' window around our initial endpoints. This means if our detector initially picked a high at, say, $10.50, but within a few bars before or after, the price actually hit $10.75, we'll adjust our swing's high endpoint to $10.75. Similarly, if the low was initially picked at $9.50 but the true low was $9.25, we'll adjust to that. This adjustment is performed by a new function, `_adjust_to_best_extrema()`, which takes the detected swing, the historical price data (highs and lows), and a lookback period as input. It then scans this window, identifies the most extreme price point (highest high or lowest low), and updates the swing's endpoints accordingly. Crucially, after these endpoints are adjusted, we'll **re-validate the protection** associated with the swing. Why? Because changing the endpoints might alter whether the swing meets our predefined protection criteria. This ensures that only robust, refined swings pass through our filters. This meticulous adjustment process is designed to significantly reduce those pesky endpoint-related false positives, leading to cleaner, more reliable trading signals and a more efficient trading strategy overall. By adding this layer of refinement, we're not just improving accuracy; we're building a more resilient system that adapts to the nuances of market price action.

The Algorithm: Finding the True Extremes

Let's get a bit technical and break down the logic behind the Best Extrema Adjustment algorithm. The core function, `_adjust_to_best_extrema()`, is designed to be precise and efficient. When it receives a `swing` dictionary (which contains the initial `high_bar_index`, `high_price`, `low_bar_index`, and `low_price`), along with the historical `highs` and `lows` arrays and a defined `lookback` window, it gets to work. First, it makes a copy of the original swing data to avoid modifying it directly. Then, it focuses on adjusting the high endpoint. It takes the original `high_bar_index`, calculates a window of bars to search within – from `high_idx - lookback` to `high_idx + lookback` (making sure not to go beyond the bounds of our data). Within this `window_highs`, it finds the index of the *absolute highest price* using `np.argmax()`. This offset is then used to calculate the `best_high_idx` in the original `highs` array. The `adjusted` swing dictionary is updated with this new, more accurate `high_bar_index` and the corresponding `high_price`. The process is mirrored for the low endpoint. It uses the original `low_bar_index`, defines a similar search window, and then finds the index of the *absolute lowest price* using `np.argmin()` within `window_lows`. This `best_low_idx` and its corresponding `low_price` are then used to update the `adjusted` swing. Finally, and this is critical, the `size` of the swing is recalculated based on these newly adjusted `high_price` and `low_price`. This ensures all subsequent filters that rely on swing size are working with the most accurate data. The beauty of this algorithm lies in its focused approach: it doesn't try to re-detect the swing from scratch; it simply refines the existing boundaries within a tight, relevant window. This makes it computationally efficient while delivering significant improvements in endpoint accuracy. The `lookback` parameter is key here – it determines how far our detector will search for a better extremum, balancing thoroughness with performance. A carefully chosen `lookback` ensures we find genuinely better points without incurring excessive computational cost.

Pipeline Integration: Where Does It Fit In?

Understanding where the Best Extrema Adjustment fits into our overall workflow is crucial for appreciating its impact. Our current swing detection process is a multi-stage pipeline, a sequence of steps designed to filter and refine potential trading signals. Here's how the new adjustment step is integrated:

Swing detection (vectorized): This is the initial phase where potential swing points are identified across the price data.
Pairing and validation: Here, the detected highs and lows are paired up to form potential swings, and some basic validation checks are performed.
Best extrema adjustment ← NEW: This is the critical new stage. Immediately after a swing is paired and validated (meaning it meets initial criteria), we apply our `_adjust_to_best_extrema()` function. It refines the high and low endpoints within their respective lookback windows.
Protection validation (re-validate with adjusted endpoints): Because we've potentially changed the swing's endpoints, we must re-check if it still meets our 'protection' criteria. These criteria are designed to ensure the swing is significant and not easily invalidated by minor price fluctuations. If the adjusted endpoints no longer meet these rules, the swing is discarded.
Size filter: Swings are filtered based on their calculated size (after adjustment).
Prominence filter: Further filtering based on how significant the swing is compared to its surroundings.
Redundancy filtering: Removing duplicate or overlapping swings.
Ranking: Assigning a rank or score to the remaining valid swings.
max_rank filter: Applying a final filter based on the highest ranked swings.

By inserting the Best Extrema Adjustment *after* initial pairing and *before* the crucial protection validation, we ensure that we are validating the best possible representation of the swing. This placement is strategic: it allows us to leverage the initial detection but then apply a powerful refinement before committing to the swing's validity. If the adjustment leads to a swing that fails protection, it means the initial detection might have been misleading or that the 'better' extremum created a less robust structure according to our rules. This iterative refinement is key to building a highly accurate and reliable trading system. The success of this integration relies on ensuring that the adjustment step itself is efficient enough not to cause significant performance degradation, which brings us to implementation and testing considerations.

Implementation Details: Bringing It to Life

Rolling out the Best Extrema Adjustment feature requires specific changes within our codebase. The primary goal is to introduce the new functionality seamlessly without disrupting existing processes and to ensure it's configurable. Here's a breakdown of the implementation steps:

Changes Required:

New function `_adjust_to_best_extrema()`: This function, as detailed in the algorithm section, will be created within the `swing_detector.py` file. It encapsulates the logic for finding and applying the best extrema within a lookback window.
New parameter `adjust_extrema: bool = True` in `detect_swings()`: To provide flexibility, we're adding a new boolean parameter to the main `detect_swings()` function. By default, this will be set to `True`, meaning the adjustment will be active. Traders can then choose to disable it by setting `adjust_extrema=False` if they wish to test or revert to the previous behavior. This parameter control is essential for comparative analysis and debugging.
Call adjustment after pairing loop, before protection validation: The code within `swing_detector.py` responsible for iterating through detected swings will be modified. After a swing has been identified and initially paired, and before the protection validation checks are applied, our new `_adjust_to_best_extrema()` function will be called. This involves passing the relevant swing data, price arrays, and the lookback value.
Re-validate protection: This is a critical consequence of the adjustment. Since the `high_bar_index`, `high_price`, `low_bar_index`, and `low_price` of a swing might change after adjustment, the protection validation step needs to be reapplied using these *new* endpoints. If the adjusted swing fails these checks (e.g., it becomes too small, or a protection line is now breached), it should be discarded. This ensures that only swings that remain robust *after* endpoint refinement pass through the pipeline.

Files Affected:

`src/swing_analysis/swing_detector.py`: This is the core file where the new function will reside, the parameter will be added to `detect_swings()`, and the call site for the adjustment function will be implemented.
`tests/test_swing_detector.py`: To ensure the new functionality works as expected and doesn't break existing logic, comprehensive tests will be added to this file.

This methodical implementation ensures that the new feature is robust, configurable, and properly integrated into the existing analytical framework. The focus on re-validating protection after adjustment is key to maintaining the integrity of our swing detection process.

Testing: Ensuring Accuracy and Performance

Thorough testing is paramount to ensure the new Best Extrema Adjustment feature functions correctly, improves our detection accuracy, and doesn't introduce performance issues. We need a multi-pronged testing strategy covering unit tests, integration tests, and performance analysis.

Testing Strategy:

Unit tests for `_adjust_to_best_extrema()`: We'll start by writing specific unit tests for the new adjustment function itself. These tests will cover various scenarios:
- A swing where the initial endpoint is already the best extremum.
- A swing where the best extremum is a few bars before the initial endpoint.
- A swing where the best extremum is a few bars after the initial endpoint.
- Edge cases, such as swings near the beginning or end of the data series, ensuring the lookback window logic correctly handles boundaries (e.g., `max(0, ...)` and `min(len(data), ...)`).
- Tests with different `lookback` values to ensure they are applied correctly.
Integration test: verify adjusted swings pass protection validation: After a swing's endpoints are adjusted, it must still satisfy our protection criteria. An integration test will simulate scenarios where an initial swing might fail protection, but after adjustment, it either passes (if the adjusted endpoints are more robust) or fails (if the adjusted endpoints make it weaker). We need to confirm that the protection validation logic correctly re-evaluates the swing based on its *adjusted* characteristics.
Test that `adjust_extrema=False` preserves original behavior: This is a crucial regression test. When the new `adjust_extrema` parameter is set to `False`, the `detect_swings()` function should behave exactly as it did before this change. This involves comparing the output of `detect_swings()` with and without the adjustment enabled, ensuring no unintended side effects on the original swing detection logic.
Verify no performance regression (should be O(N) additional): The Best Extrema Adjustment is designed to be an efficient post-processing step, ideally adding only linear time complexity (O(N)) to the overall detection process, where N is the number of bars. We will conduct performance tests to measure the execution time of `detect_swings()` with and without the adjustment enabled. This analysis will confirm that the new feature doesn't introduce significant delays, which is critical for real-time or high-frequency trading applications. We expect the overhead to be minimal, justifying its inclusion.

By rigorously applying these tests, we can gain high confidence that the Best Extrema Adjustment feature is not only mathematically sound and effective in improving endpoint accuracy but also robust, reliable, and performant within our trading system. Passing these tests is essential for meeting our acceptance criteria and confidently deploying this enhancement.

Acceptance Criteria: What Success Looks Like

To ensure that the implementation of the Best Extrema Adjustment meets our objectives and delivers the expected improvements, we've defined a clear set of acceptance criteria. These criteria serve as a checklist to verify that all aspects of the new feature have been implemented correctly and function as intended. Meeting these criteria will signify that the enhancement is ready for deployment.

Key Acceptance Criteria:

[ ] New `adjust_extrema` parameter added to `detect_swings()`: The `detect_swings()` function must include a new boolean parameter, `adjust_extrema`, which defaults to `True`. This parameter must be functional, allowing users to enable or disable the adjustment feature.
[ ] Endpoints adjusted to best extrema within lookback window: The core functionality must be verified. For any given swing, its high and low endpoints must be demonstrably adjusted to the highest high and lowest low, respectively, within the specified lookback period. This will be confirmed through unit and integration tests.
[ ] Protection validation runs on adjusted endpoints: A critical aspect is re-validation. After endpoints are adjusted, the swing must be passed through the protection validation logic *again* using the new endpoints. Swings that become invalid due to endpoint adjustment must be correctly filtered out.
[ ] Tests added and passing: All required unit tests, integration tests, regression tests, and performance tests (as outlined in the testing section) must be implemented and successfully pass. This includes tests for edge cases and the `adjust_extrema=False` scenario.
[ ] No regression in existing tests: Beyond the new tests, all pre-existing tests for the `swing_detector` module must continue to pass without modification. This ensures that the new feature hasn't negatively impacted any previously stable functionality.

Successfully meeting these acceptance criteria will provide strong assurance that the Best Extrema Adjustment feature is correctly implemented, effectively improves swing detection accuracy by refining endpoints, and integrates smoothly into our existing trading system without introducing performance regressions or breaking current functionality. This rigorous validation process is key to building confidence in the enhancement before its widespread use.

Expected Impact: Sharper Signals, Fewer False Positives

The primary objective behind implementing the Best Extrema Adjustment is to significantly enhance the quality of our swing detection signals. Based on the analysis of our Ver3 sessions, we anticipate a substantial reduction in false positives directly attributable to suboptimal endpoint selection. Specifically, we expect this new feature to **reduce better_high/better_low FPs by approximately 50%**. This is a game-changer. By ensuring that our detected swings are anchored to their true highest highs and lowest lows within a relevant window, we are effectively sharpening the definition of each trading signal. This means fewer instances where a trade is initiated based on a slightly misjudged price extreme, leading to:

Improved Entry Prices: Trades will, on average, start with more favorable pricing as the endpoints more accurately reflect the market's true turning points.
Reduced False Positives: As highlighted, a ~50% reduction in these specific types of FPs means less noise in our trading signals, allowing us to focus on higher-probability opportunities.
Enhanced Profitability: Sharper entries and fewer false signals directly translate to potentially higher profits and a more consistent performance.
Increased Confidence: A more accurate and reliable detection system builds trader confidence, leading to better decision-making and execution.

This ~50% reduction in specific false positives is not just a statistic; it represents a significant improvement in the signal-to-noise ratio of our trading system. It means our detector is not just finding swings, but finding *better-defined* swings. This refinement is crucial for any trading strategy that relies on precise identification of market turning points and price levels. The added computational cost is expected to be minimal, making this an extremely high-value enhancement. By fine-tuning these critical swing endpoints, we're taking a significant step towards a more robust, accurate, and ultimately, more profitable trading approach.

For further reading on advanced trading strategies and market analysis, consider exploring resources from Investopedia or the BabyPips.com technical analysis section.