Schism2 Strategy Deep Analysis

Strategy Number: #376 (376th of 465 strategies)
Strategy Type: Multi-condition trend following + Dynamic take-profit/stop-loss + Real-time position awareness + Multi-currency adaptation
Timeframe: 5 minutes (5m) + 1-hour information layer (1h)

---

1. Strategy Overview

Schism2 is an evolved version of the Schism strategy, developed by @werkkrew and @JimmyNixx. It adds advanced features such as multi-currency adaptation, dynamic information pairs, and Per-pair parameter support on top of the original framework. The strategy maintains the core design philosophy of "sticky buy signals" and "dynamic stop-loss mechanisms" while extending full support for BTC and ETH as stake currencies.

Evolution Note: The author explicitly states "This strategy is an evolution of our previous framework 'Schism'", indicating Schism2 is a comprehensive upgrade of the original Schism.

Core Features

Feature	Description
Buy Conditions	2 independent buy signal groups (new position buy + position continuation signals), supports BTC/ETH stake extended conditions
Sell Conditions	Dynamic stop-loss + Tiered ROI take-profit, combined with other trade status decisions
Protection Mechanisms	Order timeout protection, entry confirmation, price slippage protection, Per-pair parameter isolation
Timeframe	Main timeframe 5m + Information timeframe 1h + Dynamic COIN/FIAT information pairs
Sub-Strategies	Schism2_BTC (15m timeframe), Schism2_ETH (5m timeframe)
Dependencies	numpy, talib, qtpylib, arrow, pandas, typing, functools, datetime, freqtrade.persistence.Trade, technical.indicators.RMI, statistics.mean, cachetools.TTLCache

---

2. Strategy Configuration Analysis

2.1 Basic Risk Parameters

# ROI exit table
minimal_roi = {
    "0": 0.05,     # Immediately requires 5% profit
    "10": 0.025,   # After 10 minutes requires 2.5%
    "20": 0.015,   # After 20 minutes requires 1.5%
    "30": 0.01,    # After 30 minutes requires 1%
    "720": 0.005,  # After 12 hours requires 0.5%
    "1440": 0      # After 24 hours accepts any profit
}

# Stop-loss setting
stoploss = -0.30  # 30% hard stop-loss (more conservative than Schism)

# Signal configuration
use_sell_signal = True
sell_profit_only = True
ignore_roi_if_buy_signal = True  # Core mechanism: Ignore ROI when buy signal continuation is active

Design Philosophy:

• ROI thresholds are more aggressive than Schism, starting at 5% (Schism is 10%)
• Stop-loss is more conservative: -30% (Schism is -40%)
• Time dimension extends to 12 hours (720 minutes), adapting to longer holdings

2.2 Buy Parameters

buy_params = {
    'inf-pct-adr': 0.83534,    # ADR percentile threshold (more precise)
    'inf-rsi': 57,             # Information layer RSI lower limit (higher than Schism)
    'mp': 64,                   # Momentum Pinball upper limit (higher than Schism)
    'rmi-fast': 49,             # Fast RMI upper limit (higher than Schism)
    'rmi-slow': 24,             # Slow RMI lower limit (higher than Schism)
    'xinf-stake-rmi': 45,       # STAKE/FIAT information layer RMI upper limit (BTC/ETH specific)
    'xtf-fiat-rsi': 28,         # COIN/FIAT RSI lower limit (BTC/ETH specific)
    'xtf-stake-rsi': 90         # STAKE/FIAT RSI upper limit (BTC/ETH specific)
}

Parameter Comparison (Schism vs Schism2):

Parameter	Schism	Schism2	Change Interpretation
inf-rsi	30	57	Higher RSI threshold, avoiding extreme oversold
mp	50	64	More relaxed momentum limit
rmi-fast	20	49	Allows higher fast RMI
rmi-slow	20	24	Higher slow RMI lower limit
inf-pct-adr	0.8	0.83534	More precise ADR calculation

2.3 Order Type Configuration

The strategy does not explicitly define order_types, using Freqtrade default configuration.

---

3. Buy Conditions Detailed

3.1 Technical Indicator System

Schism2 inherits Schism's core indicator system and extends multi-currency support:

Indicator Category	Specific Indicator	Parameters	Purpose
Momentum	RMI-slow	length=21, mom=5	Trend direction judgment
Momentum	RMI-fast	length=8, mom=4	Fast signal capture
Momentum	ROC	timeperiod=6	Rate of change measurement
Composite	Momentum Pinball	RSI(ROC, 6)	Overbought/oversold positioning
Trend	RMI-up-trend/dn-trend	rolling(3) >= 2	Trend confirmation
Info Layer	RSI_1h	timeperiod=14	Higher-dimension trend judgment
Info Layer	1d_high/3d_low	rolling(24/72)	Price range positioning
BTC/ETH Specific	STAKE_rsi	timeperiod=14	STAKE/FIAT RSI
BTC/ETH Specific	STAKE_rmi_1h	length=21, mom=5	STAKE/FIAT RMI
BTC/ETH Specific	FIAT_rsi	timeperiod=14	COIN/FIAT RSI

3.2 Dynamic Information Pairs

When stake currency is BTC or ETH, the strategy automatically adds extra information pairs:

def informative_pairs(self):
    pairs = self.dp.current_whitelist()
    informative_pairs = [(pair, self.inf_timeframe) for pair in pairs]
    
    # BTC/ETH Stake expansion
    if self.config['stake_currency'] in ('BTC', 'ETH'):
        for pair in pairs:
            coin, stake = pair.split('/')
            coin_fiat = f"{coin}/{self.custom_fiat}"  # e.g., XLM/USD
            informative_pairs += [(coin_fiat, self.timeframe)]
        
        stake_fiat = f"{self.config['stake_currency']}/{self.custom_fiat}"  # e.g., BTC/USD
        informative_pairs += [(stake_fiat, self.timeframe)]
        informative_pairs += [(stake_fiat, self.inf_timeframe)]
    
    return informative_pairs

Information Pair Matrix:

Stake Currency	Extra Information Pairs	Timeframe
USDT/USDC	None	-
BTC	COIN/USD, BTC/USD	5m + 1h
ETH	COIN/USD, ETH/USD	5m + 1h

3.3 Buy Condition Classification

Condition Group #1: New Position Buy Signal (No Active Trade)

Base Conditions (All stake currencies):

conditions = [
    close <= 3d_low_1h + 0.83534 * ADR_1h,           # Price positioning
    RSI_1h >= 57,                                     # Information layer RSI
    rmi-dn-trend == 1,                                # RMI downtrend
    rmi-slow >= 24,                                   # Slow RMI lower limit
    rmi-fast <= 49,                                   # Fast RMI upper limit
    mp <= 64,                                         # Momentum Pinball
    volume > 0                                        # Volume
]

BTC/ETH Stake Extended Conditions:

if stake_currency in ('BTC', 'ETH'):
    conditions += [
        (STAKE_rsi < 90) | (FIAT_rsi > 28),           # STAKE or FIAT condition
        STAKE_rmi_1h < 45                             # STAKE information layer RMI
    ]

Logic Interpretation:

• STAKE_rsi < 90: If stake (BTC/ETH) RSI is not too high, stake itself is not overbought
• FIAT_rsi > 28: Or COIN/FIAT (e.g., XLM/USD) RSI is not extremely oversold
• STAKE_rmi_1h < 45: STAKE/FIAT 1-hour RMI is not too high

Design Philosophy: When using BTC or ETH as stake, not only look at the trading pair itself, but also check stake's performance. If BTC is surging (high RSI), it might not be a good entry timing.

Condition Group #2: Position Continuation Buy Signal (Active Trade Exists)

# profit_factor calculation
profit_factor = 1 - (rmi_slow / 400)  # Same as Schism

# rmi_grow calculation (linear growth)
rmi_grow = linear_growth(30, 70, 180, 720, open_minutes)

conditions = [
    rmi-up-trend == 1,                                # RMI uptrend
    current_profit > peak_profit * profit_factor,     # Dynamic profit factor
    rmi-slow >= rmi_grow                              # RMI dynamic threshold
]

3.4 Buy Conditions Summary

Condition Group	Applicable Scenario	Core Logic
New position buy	No active trade	Information layer positioning + RMI contrarian bottom fishing + Momentum confirmation + BTC/ETH extension
Position continuation	Active trade exists	Trend confirmation + Dynamic profit factor + RMI growth threshold

---

4. Sell Logic Detailed

4.1 Tiered Take-Profit System (ROI)

The strategy uses a time-decay ROI mechanism:

Holding Time      Profit Threshold    Description
─────────────────────────────────────────────────
0 minutes         5%                  Quick take-profit target
10 minutes        2.5%                Medium-short-term target
20 minutes        1.5%                Lowered expectations
30 minutes        1%                  Accept small profit
720 minutes       0.5%                After 12 hours
1440 minutes      0%                  After 24 hours accept any profit

Comparison with Schism:

Time	Schism ROI	Schism2 ROI	Change
0	10%	5%	More aggressive
15/10	5%	2.5%	More aggressive
30	2.5%	1%	More aggressive
60/720	1%	0.5%	Extended to 12 hours
120/1440	0.5%	0%	Consistent

4.2 Dynamic Stop-Loss Sell

Sell logic is consistent with Schism, used for "dynamic stop-loss":

if active_trade:
    loss_cutoff = linear_growth(-0.03, 0, 0, 300, open_minutes)
    
    conditions = [
        current_profit < loss_cutoff,
        current_profit > stoploss,                    # -30% vs Schism's -40%
        rmi-dn-trend == 1,
        volume > 0
    ]
    
    if peak_profit > 0:
        conditions += [rmi-slow crossed_below 50]
    else:
        conditions += [rmi-slow crossed_below 10]
    
    # Global position awareness
    if other_trades:
        if free_slots > 0:
            max_market_down = -0.04
            hold_pct = (1 / free_slots) * max_market_down
            conditions += [avg_other_profit >= hold_pct]
        else:
            conditions += [biggest_loser == True]

4.3 Per-pair Parameter Support

Schism2 adds get_pair_params method, supporting independent parameters for different trading pairs:

def get_pair_params(self, pair: str, params: str) -> Dict:
    buy_params = self.buy_params
    sell_params = self.sell_params
    minimal_roi = self.minimal_roi
    
    if self.custom_pair_params:
        custom_params = next(
            (item for item in self.custom_pair_params if pair in item['pairs']),
            None
        )
        if custom_params:
            if custom_params['buy_params']:
                buy_params = custom_params['buy_params']
            if custom_params['sell_params']:
                sell_params = custom_params['sell_params']
            if custom_params['minimal_roi']:
                minimal_roi = custom_params['minimal_roi']
    
    return {'buy': buy_params, 'sell': sell_params, 'minimal_roi': minimal_roi}

Configuration Example:

custom_pair_params = [
    {
        'pairs': ['BTC/USDT', 'ETH/USDT'],
        'buy_params': {'inf-rsi': 40, 'mp': 50},
        'minimal_roi': {"0": 0.08, "30": 0.04}
    },
    {
        'pairs': ['DOGE/USDT'],
        'buy_params': {'inf-rsi': 25, 'mp': 70},
        'minimal_roi': {"0": 0.15, "60": 0.05}
    }
]

---

5. Technical Indicator System

5.1 Core Indicators

Indicator Category	Specific Indicator	Purpose
Relative Momentum Index	RMI-slow (21, 5)	Main trend judgment
Relative Momentum Index	RMI-fast (8, 4)	Fast signal
Rate of Change	ROC (6)	Momentum measurement
Momentum Pinball	MP = RSI(ROC, 6)	Overbought/oversold positioning
Trend Direction	RMI-up/dn	Single period direction
Trend Strength	RMI-up-trend/dn-trend	Three-period confirmation

5.2 Information Timeframe Indicators (1h)

Consistent with Schism:

• RSI_1h: 14-period RSI
• 1d_high: 24-hour high
• 3d_low: 72-hour low
• ADR: Average Daily Range

5.3 BTC/ETH Specific Indicators

Indicator	Timeframe	Purpose
STAKE_rsi	5m	STAKE/FIAT (e.g., BTC/USD) RSI
STAKE_rmi_1h	1h	STAKE/FIAT RMI information layer
FIAT_rsi	5m	COIN/FIAT (e.g., XLM/USD) RSI

---

6. Risk Management Features

6.1 Hard Stop-Loss Combined with Dynamic Stop-Loss

Stop-Loss Type	Schism	Schism2	Change
Hard stop-loss	-40%	-30%	More conservative
Dynamic stop-loss	-3% → 0%	-3% → 0%	Consistent

Schism2 Stop-Loss More Conservative: Adjusted from -40% to -30%, reducing maximum single-trade loss.

6.2 Per-pair ROI Support

Schism2 adds min_roi_reached method, supporting per-pair ROI threshold retrieval:

def min_roi_reached_entry(self, trade_dur: int, pair: str = 'backtest'):
    minimal_roi = self.get_pair_params(pair, 'minimal_roi')
    roi_list = list(filter(lambda x: x <= trade_dur, minimal_roi.keys()))
    if not roi_list:
        return None, None
    roi_entry = max(roi_list)
    return roi_entry, minimal_roi[roi_entry]

def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime):
    trade_dur = int((current_time.timestamp() - trade.open_date_utc.timestamp()) // 60)
    _, roi = self.min_roi_reached_entry(trade_dur, trade.pair)
    if roi is None:
        return False
    return current_profit > roi

6.3 Order Timeout and Entry Confirmation

Consistent with Schism:

• check_buy_timeout: Cancel buy order if slippage > 1%
• check_sell_timeout: Cancel sell order if slippage > 1%
• confirm_trade_entry: Reject entry if pre-entry slippage > 1%

6.4 Price Cache Mechanism

custom_current_price_cache: TTLCache = TTLCache(maxsize=100, ttl=300)  # 5-minute TTL

---

7. Strategy Advantages and Limitations

✅ Advantages

1. Multi-Currency Adaptation: Full support for BTC/ETH as stake currency, automatically adding relevant information pairs

2. Per-pair Parameter Isolation: Can set independent buy parameters, sell parameters, and ROI for different trading pairs

3. Sub-Strategy Extension: Built-in Schism2_BTC and Schism2_ETH subclasses, optimized for different stakes

4. More Conservative Stop-Loss: -30% vs Schism's -40%, reducing maximum single-trade loss

5. More Aggressive ROI: Starts at 5% (Schism is 10%), adapting to faster pace

⚠️ Limitations

1. Live Trading Only: Same as Schism, core features not compatible with backtesting

2. More Parameters: 8 buy parameters (Schism has 5), harder optimization

3. Information Pair Dependency: BTC/ETH stake requires extra API calls, increasing latency risk

4. Higher Complexity: Multi-currency adaptation + Per-pair parameters, significantly increased configuration complexity

5. Overfitting Risk: More parameters mean higher overfitting risk

---

8. Applicable Scenario Recommendations

Market Environment	Recommended Configuration	Description
BTC Stake	Schism2_BTC sub-strategy	15m timeframe, optimized for BTC
ETH Stake	Schism2_ETH sub-strategy	5m timeframe, optimized for ETH
USDT Stake	Base Schism2	No extra information pairs needed
Multiple Trading Pairs	Configure custom_pair_params	Set independent parameters for different coins

---

9. Applicable Market Environment Details

Schism2 series is an "evolved bottom-fishing trend following strategy". Based on its code architecture and Schism series' live trading verification experience, it is best suited for rebound markets after oscillating declines, while adding specific optimization for BTC/ETH stake.

9.1 Strategy Core Logic

• Bottom fishing with extension: Besides original Schism's conditions, also checks STAKE/FIAT and COIN/FIAT status
• Trend continuation: Same position continuation mechanism as Schism, maximizing trend returns
• Per-pair customization: Different coins can use different parameters, avoiding "one-size-fits-all"
• Sub-strategy isolation: BTC and ETH stakes have independently optimized subclasses

9.2 Performance in Different Market Environments

Market Type	Performance Rating	Reason Analysis
📈 Slow bull market	⭐⭐⭐⭐⭐	Trend continuation mechanism fully plays out, maximized holding returns
🔄 Choppy market	⭐⭐⭐⭐☆	Per-pair parameters can optimize for different coins
📉 One-sided crash	⭐⭐☆☆☆	Bottom fishing signals may trigger too early, stop-loss risk exists
⚡️ Rapid rise/fall	⭐⭐☆☆☆	Order protection may fail, high slippage risk

9.3 Key Configuration Recommendations

Configuration Item	Recommended Value	Description
max_open_trades	3-5	Coordinate with global position awareness
stake_currency	USDT/BTC/ETH	All three supported
timeframe	5m (ETH) / 15m (BTC)	Adjust according to sub-strategy
custom_pair_params	Optional	Configure for special coins

---

10. Important Warning: The Cost of Complexity

10.1 Learning Curve

Schism2 code is approximately 350 lines, including:

• Multi-timeframe indicator calculations
• Dynamic information pair management
• Per-pair parameter system
• Sub-strategy inheritance mechanism
• Real-time database queries

It is recommended to first master Schism before upgrading to Schism2.

10.2 Hardware Requirements

Number of Trading Pairs	Stake Type	Minimum Memory	Recommended Memory
1-10 pairs	USDT	2 GB	4 GB
1-10 pairs	BTC/ETH	4 GB	8 GB
10-30 pairs	USDT	4 GB	8 GB
10-30 pairs	BTC/ETH	8 GB	16 GB
30+ pairs	Any	16 GB	32 GB

Note: BTC/ETH stake requires extra information pair API calls, significantly increasing memory and network overhead.

10.3 Differences Between Backtesting and Live Trading

Same as Schism:

• ignore_roi_if_buy_signal and position continuation signals only work in live trading/dry run
• Cannot access Trade.get_trades() data during backtesting
• Backtesting results may differ significantly from live trading performance

Recommended Workflow:

1. First use Schism to familiarize with core logic
2. Use dry_run to verify Schism2's extended features
3. Finally small position live trading verification

10.4 Manual Trader Recommendations

Schism2's core concepts can be borrowed:

• Multi-dimensional confirmation: Not only look at trading pair itself, but also stake currency's status
• Per-pair customization: Different coins have different "temperaments", parameters can be differentiated
• Sub-strategy isolation: Use different configurations for different scenarios

---

11. Summary

Schism2 is an "evolved bottom-fishing trend following strategy", adding multi-currency adaptation, Per-pair parameters, and sub-strategy extension on top of Schism. Its core value lies in:

1. Full Multi-Currency Support: BTC/ETH stake automatically adds COIN/FIAT and STAKE/FIAT information pairs
2. Per-pair Parameter Isolation: Different trading pairs can use different buy parameters and ROI
3. Sub-Strategy Extension: Schism2_BTC and Schism2_ETH optimized for different scenarios
4. More Conservative Risk Control: Stop-loss -30% (vs Schism's -40%), more aggressive ROI (starts at 5%)

For quantitative traders, Schism2 is an advanced live trading strategy, suitable for traders already familiar with Schism who need more flexibility and multi-currency support. It is recommended to first master Schism's core logic before upgrading to Schism2.