Der Anfang von allem

Ich betreibe schon seit einiger Zeit quantitativen Handel. Ehrlich gesagt lese ich meistens nur die Strategien anderer und versuche dann, die Parameter anzupassen. Ich habe nicht oft die Möglichkeit, eine Strategie von Grund auf neu zu entwickeln, hauptsächlich weil mir die guten Ideen fehlen und der Weg von der Idee zum Code recht weit erscheint.

Ich hatte vor einiger Zeit frei und habe wieder angefangen, den Sender B zu durchsuchen. Dabei bin ich zufällig auf die Live-Übertragung von Bruder Z gestoßen. Ich habe sie nur beiläufig angesehen, aber ich hatte nicht erwartet, dass sie mir eine unerwartete Inspiration geben würde.

Diese erstaunliche Zusammenfassung

Als Bruder Z über den KDJ-Indikator sprach, postete ein Internetnutzer im Kommentarbereich einen Satz, den ich besonders interessant fand:

„Wenn der Preis leicht fällt, fällt der Haken schnell, was auf einen zukünftigen Aufwärtstrend hindeuten kann. Wenn der Preis stark fällt, fällt der Haken langsam, was auf einen weiteren Rückgang in der Zukunft hindeuten kann. Wenn der Preis leicht steigt, wächst die Rille schnell, was auf einen zukünftigen Abwärtstrend hindeuten kann. Wenn der Preis stark steigt, wächst der Haken langsam, was auf einen weiteren Anstieg in der Zukunft hindeuten kann.“

Ich war damals fassungslos. Diese Zusammenfassung ist so aufschlussreich! Obwohl es nur ein Satz ist, scheint sie die sich ändernden Regeln des J-Werts von KDJ klar zu erklären.

Ich dachte mir: Bruder Z ist an der Börse, aber diese Logik sollte doch auch für Kryptowährungen gelten, oder? Je mehr ich darüber nachdachte, desto schlüssiger erschien sie mir. Das Ausmaß der Preisänderungen und die Geschwindigkeit der Indikatorreaktionen – diese beiden Dimensionen zusammengenommen, um den nachfolgenden Trend zu beurteilen – klangen sehr logisch. Zudem wird auf dem Kryptowährungsmarkt rund um die Uhr gehandelt, und die Volatilität ist höher, sodass diese Theorie vielleicht besser funktioniert.

In diesem Moment war ich etwas aufgeregt und hatte das Gefühl, eine Richtung gefunden zu haben, die es zu erforschen galt. Doch dann machte ich mir wieder Sorgen: Wie könnte ich diese Idee in Code umsetzen? Früher habe ich in solchen Situationen entweder darüber nachgedacht oder es beiseite gelegt und es später umgesetzt, wenn ich Zeit hatte.

Beschlossen, es zu versuchen

Aber dieses Mal ist es anders. Ich erinnerte mich daran, dass die Inventor-Plattform über einen KI-Assistenten verfügt, und wollte versuchen, diese Idee direkt in Code umzusetzen.

Mit einer Ausprobier-Einstellung öffnete ich den KI-Assistenten der Inventor Platform, gab die Idee wörtlich ein und fügte hinzu: Dies ist eine auf Aktien angewandte Theorie, und ich möchte sie an Kryptowährungen ausprobieren.

Ich hatte nicht erwartet, dass die KI so schnell versteht und schnell einen kompletten Satz Strategiecodes für mich generiert. In diesem Moment war ich ziemlich überrascht und dachte: Ist die KI jetzt so mächtig?

Erste Version des Strategiecodes:

/*backtest
start: 2024-07-18 09:40:00
end: 2025-06-30 15:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("KDJ J值变化速度策略", overlay=false)

// 输入参数 - 针对加密货币市场优化
kdj_length = input.int(14, "KDJ周期", minval=1)
k_smooth = input.int(3, "K平滑", minval=1)
d_smooth = input.int(3, "D平滑", minval=1)
j_speed_period = input.int(5, "J值变化速度计算周期", minval=1)
price_change_threshold = input.float(3.0, "价格变化幅度阈值(%)-区分大小幅", minval=0.1) / 100
j_speed_threshold = input.float(12.0, "J值变化速度阈值-区分快慢", minval=0.1)
j_change_threshold = input.float(1.5, "J值变化忽略阈值-过滤噪音", minval=0.1)
price_change_ignore_threshold = input.float(0.5, "价格变化忽略阈值(%)-过滤噪音", minval=0.01) / 100

// 加密货币风控参数
max_consecutive_trades = input.int(5, "最大连续交易次数", minval=1)
min_bars_between_signals = input.int(3, "信号间最小间隔K线数", minval=1)
enable_stop_loss = input.bool(true, "启用止损")
stop_loss_pct = input.float(5.0, "止损百分比(%)", minval=0.5) / 100

// 计算KDJ指标
highest_high = ta.highest(high, kdj_length)
lowest_low = ta.lowest(low, kdj_length)
rsv = (close - lowest_low) / (highest_high - lowest_low) * 100

k = ta.sma(rsv, k_smooth)
d = ta.sma(k, d_smooth)
j = 3 * k - 2 * d

// 计算J值连续变化速度
// 统计连续上涨或下跌的累计变化量和持续时间
var float j_cumulative_change = 0.0
var int j_consecutive_bars = 0
var int j_direction = 0  // 1为上涨，-1为下跌，0为初始

j_current_change = j - j[1]
// 只有变化幅度超过阈值才认为有方向性
j_current_direction = math.abs(j_current_change) > j_change_threshold ? 
                     (j_current_change > 0 ? 1 : -1) : 0

// 检测J值方向是否改变
if j_current_direction != j_direction and j_current_direction != 0
    // 方向改变，重新开始统计
    j_cumulative_change := math.abs(j_current_change)
    j_consecutive_bars := 1
    j_direction := j_current_direction
else if j_current_direction == j_direction and j_current_direction != 0
    // 方向相同，累计变化
    j_cumulative_change += math.abs(j_current_change)
    j_consecutive_bars += 1
else if j_current_direction == 0
    // 变化太小忽略，但时间继续累计
    j_consecutive_bars += 1

// J值变化速度 = 累计变化量 / 持续时间
j_speed = j_consecutive_bars > 0 ? j_cumulative_change / j_consecutive_bars : 0

// 计算价格连续变化幅度
// 统计连续上涨或下跌的累计变化量和持续时间
var float price_cumulative_change = 0.0
var int price_consecutive_bars = 0
var int price_direction = 0  // 1为上涨，-1为下跌，0为初始

price_current_change = (close - close[1]) / close[1]
// 只有变化幅度超过阈值才认为有方向性
price_current_direction = math.abs(price_current_change) > price_change_ignore_threshold ? 
                         (price_current_change > 0 ? 1 : -1) : 0

// 检测价格方向是否改变
if price_current_direction != price_direction and price_current_direction != 0
    // 方向改变，重新开始统计
    price_cumulative_change := math.abs(price_current_change)
    price_consecutive_bars := 1
    price_direction := price_current_direction
else if price_current_direction == price_direction and price_current_direction != 0
    // 方向相同，累计变化
    price_cumulative_change += math.abs(price_current_change)
    price_consecutive_bars += 1
else if price_current_direction == 0
    // 变化太小忽略，但时间继续累计
    price_consecutive_bars += 1

// 价格变化幅度 = 累计变化量
price_change = price_cumulative_change

// 判断价格变化类型
is_small_change = price_change < price_change_threshold
is_large_change = price_change >= price_change_threshold

// 判断价格方向（基于当前连续变化方向）
is_price_up = price_direction == 1
is_price_down = price_direction == -1

// 判断J值变化速度
is_j_fast = j_speed > j_speed_threshold
is_j_slow = j_speed <= j_speed_threshold  

// 交易控制变量
var float entry_price = 0.0

// 策略信号逻辑
// 1. 小幅下跌钩掉的快，可能后期看涨
signal_small_down_fast_j = is_small_change and is_price_down and is_j_fast 

// 2. 大幅下跌勾下的慢，后期还要再跌
signal_large_down_slow_j = is_large_change and is_price_down and is_j_slow 

// 3. 小幅上涨沟长得快，可能后期看跌
signal_small_up_fast_j = is_small_change and is_price_up and is_j_fast 

// 4. 大幅上涨勾长得慢，后期可能还要再涨
signal_large_up_slow_j = is_large_change and is_price_up and is_j_slow 

// 交易信号
long_signal = (signal_small_down_fast_j or signal_large_up_slow_j) 
short_signal = (signal_small_up_fast_j or signal_large_down_slow_j) 

// 执行交易
if long_signal and strategy.position_size == 0
    strategy.entry("Long", strategy.long, comment="多头信号开仓")
    entry_price := close

    
if short_signal and strategy.position_size == 0
    strategy.entry("Short", strategy.short, comment="空头信号开仓")
    entry_price := close


// 平仓条件
// 1. 信号反转平仓
if strategy.position_size > 0 and short_signal
    strategy.close("Long", comment="信号反转平多仓")

    
if strategy.position_size < 0 and long_signal
    strategy.close("Short", comment="信号反转平空仓")


// 2. 止损平仓
if enable_stop_loss
    if strategy.position_size > 0 and close <= entry_price * (1 - stop_loss_pct)
        strategy.close("Long", comment="止损平多仓")

        
    if strategy.position_size < 0 and close >= entry_price * (1 + stop_loss_pct)
        strategy.close("Short", comment="止损平空仓")


// 绘制指标
plot(j, "J值", color=color.blue, linewidth=2)
hline(80, "超买线", color=color.red, linestyle=hline.style_dashed)
hline(20, "超卖线", color=color.green, linestyle=hline.style_dashed)
hline(50, "中线", color=color.gray, linestyle=hline.style_dotted)

// 绘制信号标记
plotshape(signal_small_down_fast_j, title="小跌快勾-看涨", location=location.belowbar, color=color.lime, style=shape.triangleup, size=size.small,overlay=true)
plotshape(signal_large_down_slow_j, title="大跌慢勾-看跌", location=location.belowbar, color=color.red, style=shape.triangledown, size=size.small,overlay=true)
plotshape(signal_small_up_fast_j, title="小涨快勾-看跌", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small,overlay=true)
plotshape(signal_large_up_slow_j, title="大涨慢勾-看涨", location=location.abovebar, color=color.lime, style=shape.triangleup, size=size.small,overlay=true)

Die Aufregung und Enttäuschung des ersten Mals

Nachdem ich den Code erhalten hatte, prüfte ich zunächst, ob er lauffähig war. Der Editor der Inventor-Plattform zeigte an, dass keine Syntaxfehler vorhanden waren, und ich war erleichtert.

Dann kommt der spannendste Moment – ​​das Online-Backtesting. Auf der Seite des Inventor AI Assistant können Sie unten rechts Online-Backtesting in Echtzeit durchführen. Wählen Sie die Backtest-Währung BTC, legen Sie den Zeitraum fest und klicken Sie auf die Schaltfläche „Online-Backtesting“.

Nach der Veröffentlichung der Ergebnisse war ich etwas zwiespältig. Der Code lief zwar, und die Logik schien korrekt, aber die Backtest-Ergebnisse waren nicht optimal. Zwar erzielte ich zeitweise Gewinne, aber die Gesamtgewinnquote war nicht hoch, und ich erlitt oft aufeinanderfolgende Verluste.

Es fühlte sich an, als wäre ein Flugzeug gebaut worden, das theoretisch fliegen könnte, aber letztendlich nicht fliegen konnte. Ich war ein wenig enttäuscht, wollte aber nicht aufgeben.

In Gedanken verfallen

Wenn die Theorie Sinn ergibt und der Code funktioniert, wo liegt dann das Problem?

Ich begann, die Logik des Codes sorgfältig zu studieren. Ich stellte fest, dass der von der KI geschriebene Code hauptsächlich anhand der Änderungsgeschwindigkeit des J-Werts zwischen „schnell“ und „langsam“ beurteilt:

j_speed = j_cumulative_change / j_consecutive_bars
is_j_fast = j_speed > j_speed_threshold
is_j_slow = j_speed <= j_speed_threshold

Auf den ersten Blick scheint alles in Ordnung zu sein, aber ich habe immer das Gefühl, dass etwas nicht stimmt.

Nachdem ich darüber nachgedacht hatte, wurde mir plötzlich ein Problem klar: Diese Berechnung betrachtet nur die Geschwindigkeit der Veränderung zu einem bestimmten Zeitpunkt, berücksichtigt aber nicht die Veränderung vonKontinuität。

Beispielsweise kann sich der J-Wert an einem bestimmten Tag schnell ändern, es handelt sich dabei jedoch nur um einen kurzen Moment und normalisiert sich am nächsten Tag wieder. In diesem Fall ist die Beurteilung anhand der Geschwindigkeit eines einzelnen Punktes möglicherweise nicht genau.

Die ursprüngliche Theorie besagt „schnelles Abhaken“ und „langsames Herunterhaken“. „Schnell“ und „langsam“ beziehen sich eher auf einen kontinuierlichen Prozess als auf den Zustand an einem bestimmten Punkt.

Den Durchbruch finden

Als ich dieses Problem erkannte, war ich wieder etwas aufgeregt. Ich hatte das Gefühl, den Schlüssel gefunden zu haben, wusste aber nicht, wie ich den Code ändern sollte.

Zu diesem Zeitpunkt fielen mir einige Kommentare ein, die ich zuvor gelesen hatte. Jemand hatte erwähnt, dass wir auf die Kontinuität der Indikatoränderungen achten sollten. Ja, Kontinuität! Genau daran habe ich gedacht.

Ich ging zurück zum KI-Assistenten und stellte diesmal eine klare Anfrage: Wir müssen die Kontinuität der Veränderung des J-Werts hervorheben. Wir können nicht nur die Veränderungsgeschwindigkeit eines einzelnen Punkts betrachten, sondern müssen den Veränderungstrend über mehrere aufeinanderfolgende Tage hinweg betrachten.

Die KI-Lösung war diesmal augenöffnend. Sie überarbeitete die gesamte Logik der J-Wert-Analyse:

1. Erfassen Sie nicht nur die aktuelle Änderungsrichtung, sondern verfolgen Sie auch die Anzahl der aufeinanderfolgenden Tage der Änderung
2. Nur wenn sich der Trend an mehreren aufeinanderfolgenden Tagen in die gleiche Richtung ändert, wird er als gültiger Trend angesehen.
3. Nachdem wir die Kontinuität bestätigt haben, können wir die Geschwindigkeit der Veränderung beurteilen.

Die zweite verbesserte Version des Strategiecodes:

/*backtest
start: 2024-07-18 09:40:00
end: 2025-06-30 15:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("KDJ J值连续性变化策略", overlay=false)

// 输入参数
kdj_length = input.int(9, "KDJ周期", minval=1)
k_smooth = input.int(3, "K平滑", minval=1)
d_smooth = input.int(3, "D平滑", minval=1)
j_speed_period = input.int(3, "J值变化速度计算周期", minval=1)
price_change_threshold = input.float(1.5, "价格变化幅度阈值(%)-区分大小幅", minval=0.1) / 100
j_fast_threshold = input.float(15.0, "J值快速变化阈值", minval=1.0)
j_slow_threshold = input.float(5.0, "J值慢速变化阈值", minval=0.1)
j_change_threshold = input.float(1.0, "J值变化忽略阈值-过滤噪音", minval=0.1)
price_change_ignore_threshold = input.float(0.2, "价格变化忽略阈值(%)-过滤噪音", minval=0.01) / 100
min_consecutive_bars = input.int(3, "最小连续K线数", minval=2)

// 风控参数
max_consecutive_trades = input.int(3, "最大连续交易次数", minval=1)
min_bars_between_signals = input.int(5, "信号间最小间隔K线数", minval=1)
enable_stop_loss = input.bool(true, "启用止损")
stop_loss_pct = input.float(3.0, "止损百分比(%)", minval=0.5) / 100

// 计算KDJ指标
highest_high = ta.highest(high, kdj_length)
lowest_low = ta.lowest(low, kdj_length)
rsv = (close - lowest_low) / (highest_high - lowest_low) * 100

k = ta.sma(rsv, k_smooth)
d = ta.sma(k, d_smooth)
j = 3 * k - 2 * d

// 改进的J值连续性变化分析
var float j_cumulative_change = 0.0  // 保持方向性的累计变化（正负数）
var int j_consecutive_bars = 0
var int j_direction = 0  // 1为连续上涨，-1为连续下跌，0为无明确方向
var float j_start_value = 0.0

j_current_change = j - j[1]
// 只有变化幅度超过阈值才认为有方向性
j_current_direction = math.abs(j_current_change) > j_change_threshold ? 
                     (j_current_change > 0 ? 1 : -1) : 0

// 重新设计J值连续性检测逻辑
if j_current_direction != 0
    if j_current_direction == j_direction
        // 方向相同，继续累计（保持正负号）
        j_cumulative_change += j_current_change
        j_consecutive_bars += 1
    else
        // 方向改变，重新开始统计
        j_cumulative_change := j_current_change
        j_consecutive_bars := 1
        j_direction := j_current_direction
        j_start_value := j[1]
else
    // 变化很小，视为横盘，重置连续性
    if j_consecutive_bars > 0
        j_consecutive_bars += 1
    else
        j_cumulative_change := 0.0
        j_consecutive_bars := 0
        j_direction := 0

// 计算J值连续性指标（保持方向性）
j_total_change = j - j_start_value  // 从起始点到当前的总变化（带正负号）
j_avg_speed = j_consecutive_bars > 0 ? j_cumulative_change / j_consecutive_bars : 0  // 平均变化速度（带正负号）
j_abs_avg_speed = math.abs(j_avg_speed)  // 变化速度的绝对值

// 新的J值变化判断逻辑
is_j_continuous_up = j_direction == 1 and j_consecutive_bars >= min_consecutive_bars
is_j_continuous_down = j_direction == -1 and j_consecutive_bars >= min_consecutive_bars

// 基于连续性和变化幅度的快慢判断
is_j_fast_up = is_j_continuous_up and j_abs_avg_speed > j_fast_threshold
is_j_slow_up = is_j_continuous_up and j_abs_avg_speed <= j_slow_threshold and j_abs_avg_speed > 0
is_j_fast_down = is_j_continuous_down and j_abs_avg_speed > j_fast_threshold  
is_j_slow_down = is_j_continuous_down and j_abs_avg_speed <= j_slow_threshold and j_abs_avg_speed > 0

// 计算价格连续变化幅度（保持原有逻辑）
var float price_cumulative_change = 0.0
var int price_consecutive_bars = 0
var int price_direction = 0

price_current_change = (close - close[1]) / close[1]
price_current_direction = math.abs(price_current_change) > price_change_ignore_threshold ? 
                         (price_current_change > 0 ? 1 : -1) : 0

if price_current_direction != price_direction and price_current_direction != 0
    price_cumulative_change := math.abs(price_current_change)
    price_consecutive_bars := 1
    price_direction := price_current_direction
else if price_current_direction == price_direction and price_current_direction != 0
    price_cumulative_change += math.abs(price_current_change)
    price_consecutive_bars += 1
else if price_current_direction == 0
    price_consecutive_bars += 1

price_change = price_cumulative_change

// 判断价格变化类型
is_small_change = price_change < price_change_threshold
is_large_change = price_change >= price_change_threshold
is_price_up = price_direction == 1
is_price_down = price_direction == -1

// 交易控制变量
var float entry_price = 0.0

// 重新设计策略信号逻辑，强调J值的连续性
// 1. 小幅下跌 + J值连续快速下钩 = 看涨（下跌惯性减弱，J值快速回落）
signal_small_down_fast_j_down = is_small_change and is_price_down and is_j_fast_down

// 2. 大幅下跌 + J值连续慢速下钩 = 看跌（下跌惯性仍在，J值缓慢下行）
signal_large_down_slow_j_down = is_large_change and is_price_down and is_j_slow_down

// 3. 小幅上涨 + J值连续快速上钩 = 看跌（上涨惯性减弱，J值快速回落）
signal_small_up_fast_j_up = is_small_change and is_price_up and is_j_fast_up

// 4. 大幅上涨 + J值连续慢速上钩 = 看涨（上涨惯性仍在，J值持续上行）
signal_large_up_slow_j_up = is_large_change and is_price_up and is_j_slow_up

// 交易信号
long_signal = (signal_small_down_fast_j_down or signal_large_up_slow_j_up) 
short_signal = (signal_small_up_fast_j_up or signal_large_down_slow_j_down) 

// 执行交易
if long_signal and strategy.position_size == 0
    strategy.entry("Long", strategy.long, comment="多头信号开仓")
    entry_price := close
    
if short_signal and strategy.position_size == 0
    strategy.entry("Short", strategy.short, comment="空头信号开仓")
    entry_price := close

// 平仓条件
if strategy.position_size > 0 and short_signal
    strategy.close("Long", comment="信号反转平多仓")
    
if strategy.position_size < 0 and long_signal
    strategy.close("Short", comment="信号反转平空仓")

// 止损平仓
if enable_stop_loss
    if strategy.position_size > 0 and close <= entry_price * (1 - stop_loss_pct)
        strategy.close("Long", comment="止损平多仓")
        
    if strategy.position_size < 0 and close >= entry_price * (1 + stop_loss_pct)
        strategy.close("Short", comment="止损平空仓")

// 绘制指标
plot(j, "J值", color=color.blue, linewidth=2)
hline(80, "超买线", color=color.red, linestyle=hline.style_dashed)
hline(20, "超卖线", color=color.green, linestyle=hline.style_dashed)
hline(50, "中线", color=color.gray, linestyle=hline.style_dotted)

// 在下方子图显示连续性指标
plot(j_consecutive_bars, "连续K线数", color=color.orange)
plot(j_avg_speed, "平均变化速度(带方向)", color=color.purple)
plot(j_abs_avg_speed, "平均变化速度(绝对值)", color=color.yellow)

// 绘制信号标记
plotshape(signal_small_down_fast_j_down, title="小跌+J快速下钩-看涨", location=location.belowbar, color=color.lime, style=shape.triangleup, size=size.small, overlay=true)
plotshape(signal_large_down_slow_j_down, title="大跌+J慢速下钩-看跌", location=location.belowbar, color=color.red, style=shape.triangledown, size=size.small, overlay=true)
plotshape(signal_small_up_fast_j_up, title="小涨+J快速上钩-看跌", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small, overlay=true)
plotshape(signal_large_up_slow_j_up, title="大涨+J慢速上钩-看涨", location=location.abovebar, color=color.lime, style=shape.triangleup, size=size.small, overlay=true)

// 背景色显示J值连续性状态
bgcolor(is_j_continuous_up ? color.new(color.green, 95) : is_j_continuous_down ? color.new(color.red, 95) : na, title="J值连续性背景")

Als ich diese Verbesserung sah, war ich begeistert und hatte das Gefühl, „das ist das Gefühl“. Jetzt ist die Änderung des J-Werts kein isolierter Punkt mehr, sondern ein kontinuierlicher Trend.

Die Überraschung des zweiten Backtests

Nachdem ich den neuen Code erhalten hatte, konnte ich es kaum erwarten, einen weiteren Backtest durchzuführen.

Das Ergebnis hat mich dieses Mal etwas überrascht. Obwohl es keine perfekte Strategie ist, ist es offensichtlich viel besser als die erste Version:

• Es gibt weniger Fehlsignale, da durch die Anforderung der Kontinuität viel Rauschen herausgefiltert wird.
• Die Gewinnquote wurde deutlich verbessert
• Die Strategielogik ist klarer

Wenn ich mir die Gewinnkurve im Backtest-Bericht anschaue, verspüre ich ein starkes Erfolgserlebnis. Obwohl es sich nicht um eine weltbewegende Strategie handelt, begann sie mit einer Idee und wurde Schritt für Schritt erkundet.

Erfahrung im Umgang mit Werkzeugen

Diese Erkundung hat mir ein neues Verständnis von KI-Assistenten und quantitativen Plattformen vermittelt.

Der Wert von KI-Assistenten:

Früher dachte ich, dass KI nur ein schwaches Hilfsmittel für die Intelligenz sei, doch diesmal habe ich festgestellt, dass sie im quantitativen Handel wirklich nützlich ist. Der größte Nutzen liegt nicht darin, menschliches Denken zu ersetzen, sondern darin, den Weg von der Idee zum Code deutlich zu verkürzen.

1. Starke Auffassungsgabe: Ich habe gerade eine Idee in sehr einfacher Sprache beschrieben, und sie kann genau verstanden und in eine vollständige strategische Logik umgewandelt werden
2. Schnelle Iterationsgeschwindigkeit: Wenn ich eine Verbesserungsanfrage stelle, kann das Problem schnell lokalisiert und eine Lösung bereitgestellt werden
3. Gute Codequalität：Der generierte Code ist nicht nur ausführbar, sondern verfügt auch über eine klare Struktur und detaillierte Kommentare

Komfort der quantitativen Plattform: Auch die Backtesting-Funktion der Inventor-Plattform hat mich beeindruckt. Früher musste man für den Backtest einer Strategie historische Daten recherchieren, ein Backtesting-Framework schreiben und sich mit verschiedenen technischen Details auseinandersetzen. Jetzt muss man nur noch den Code einfügen, die Parameter festlegen und sieht die Ergebnisse sofort.

Dieses sofortige Feedback macht den gesamten Erkundungsprozess sehr reibungslos und Ideen, Code, Überprüfung und Verbesserung bilden einen sehr schnellen Zyklus.

Einige Überlegungen

Natürlich brachte mich diese Erkundung auch zu einigen Fragen:

Einschränkungen der KI: Obwohl KI viel geholfen hat, ist sie nicht allmächtig. KI kann die Probleme der ersten Codeversion nicht selbst finden und benötigt weiterhin menschliche Analyse und Beurteilung. Zudem ist die von KI bereitgestellte Lösung möglicherweise nicht die beste und muss an die jeweilige Situation angepasst werden.

Einschränkungen der Strategie selbst: Obwohl diese Strategie im Backtesting gute Ergebnisse liefert, ist sie kein Allheilmittel. Sie funktioniert in der Regel gut in volatilen Märkten, und die Parameter müssen je nach Währung angepasst werden.

Das Wichtigste dabei ist: Nur weil eine Strategie in der Vergangenheit gute Ergebnisse erzielt hat, kann man nicht davon ausgehen, dass sie auch in Zukunft erfolgreich sein wird. Der Markt verändert sich, und Strategien müssen ständig angepasst werden.

Ein unerwarteter Bonus

Neben der Strategie selbst brachte diese Untersuchung auch einige unerwartete Gewinne:

Das Verständnis des quantitativen Handels hat sich geändert: Ich dachte immer, die Hürde für quantitativen Handel sei sehr hoch und erfordere gute Programmierkenntnisse und mathematisches Wissen. Diese Erfahrung hat mir gezeigt, dass Ideen und Logik wichtiger sind. Mit guten Tools ist die technische Hürde nicht so hoch wie gedacht.

Veränderte Einstellung zum Lernen: Wenn ich in der Vergangenheit auf interessante Ideen stieß, dachte ich immer: „Ich werde es versuchen, wenn ich Zeit habe“, aber es endete oft vergebens. Diese Erfahrung hat mir gezeigt, dass die aktuellen Tools es einfach machen, es „auszuprobieren“. Der Schlüssel liegt darin, den Mut zum Handeln zu haben.

Die Perspektive auf das Scheitern hat sich geändert: Als die erste Version der Strategie nicht funktionierte, gab ich nicht sofort auf, sondern analysierte das Problem. Dabei wurde mir klar, dass ein Misserfolg oft nicht das Ende bedeutet, sondern ein Hinweis, die richtige Richtung einzuschlagen.

Nachfolgende Pläne

Diese Strategie ist noch in meinem Code vorhanden und ich verwende sie gelegentlich. Obwohl sie nicht perfekt ist, bin ich nach einigen Untersuchungen recht zufrieden damit.

Und was noch wichtiger ist: Diese Erfahrung hat mir Selbstvertrauen gegeben. Es stellte sich heraus, dass der Weg von der Idee zur Strategie gar nicht so weit ist, wie ich mir das vorgestellt hatte.

Als nächstes möchte ich diese Erkundung fortsetzen:

• Achten Sie mehr auf einige interessante Handelstheorien und Ideen
• Versuchen Sie, einige Konzepte aus anderen Bereichen auf den Handel anzuwenden
• Nutzen Sie weiterhin KI und quantitative Plattformen, um Ideen schnell zu validieren

Ratschläge für andere

Wenn Sie auch am quantitativen Handel interessiert sind, sind meine Vorschläge:

1. Lassen Sie sich nicht von den technischen Hürden abschrecken: Die aktuellen Tools sind bereits sehr leistungsfähig, was zählt, sind Ideen und deren Umsetzung
2. Fangen Sie klein an: Sie müssen keine perfekte Strategie verfolgen, beginnen Sie mit einfachen Ideen
3. Seien Sie mutig, es zu versuchen und zu scheitern: Es ist normal, beim ersten Mal zu scheitern. Der Schlüssel liegt darin, das Problem zu analysieren und kontinuierliche Verbesserungen vorzunehmen.
4. Behalten Sie eine Lernhaltung bei: Achten Sie mehr auf unterschiedliche Standpunkte und Theorien. Inspiration kommt oft aus unerwarteter Richtung.

Abschluss

Rückblickend war der Ausgangspunkt dieser Erkundung lediglich ein Kommentar zu Bilibili, aber er ermöglichte mir, einen vollständigen quantitativen Strategieentwicklungsprozess mitzuerleben.

In einer Zeit, in der Wissen und Werkzeuge jederzeit verfügbar sind, fehlt uns vielleicht einfach der Mut zum Mut. Egal, ob Sie ein quantitativer Anfänger oder ein erfahrener Trader sind, Sie können versuchen, mit einer einfachen Idee zu beginnen und zu sehen, wohin Sie gelangen.

Die nächste interessante Strategie könnte in einem Kommentar versteckt sein, den Sie gerade gelesen haben.

Haftungsausschluss: Dies ist lediglich ein Erfahrungsaustausch und keine Anlageberatung. Der Handel ist riskant, treffen Sie Ihre Entscheidungen daher sorgfältig.