1# 屁话

偶然发现的一款策略，能神奇的不改参数适应市场
并且2018年到现在不改参数都是盈利的
比所谓的拟合策略强不知道多少倍，哈哈

后来这个策略作为一个因子伴随了我几个月的时间用于实盘

总比一直放在收藏夹吃灰，还不如分享给你们让我赚点流量
仅供分享思路，真要实盘赚钱，你要做的还很多
仅供分享思路，真要实盘赚钱，你要做的还很多

2# 原理

开仓：连续8根收盘价大于均线，最后一根收盘价小于均线
平仓：持仓3根k线，或突破最高点，或ATR，或固定止盈止损

3# 回测

4# 源码

原版：
https://www.tradingview.com/script/gl17fzdf-8-Day-Extended-Runs/

自己修改的：

import talib
import pandas as pd
from main.zhibiao import *

seting =                                                  {
    "备注": "禁用",
    "name": "Ma8",
    "symbol": "BTCUSDT_1h_Buy",
    "kTime": "1h",
    "ma_len": 29,
    "ma_type": "lsma",
    "ma_src": "o+h+l+c",
    "pianli": 14,
    "pingcang": 4,
    "tupo": 34,
    "atr_len": 43,
    "atr_mult": 2.871,
    "atr_type": "rma",
    "buy": 1,
    "buyZhiying": 96.216,
    "buyZhisun": 12.06,
    "sell": 0,
    "sellZhiying": 0,
    "sellZhisun": 0,
    "kai": 100
}

"""
MA连续偏离8次入场，十根K线后出场
"""
def Ma8(r, df, seting):

    c = len(df)
    df['ma_src'] = GetSrc(r, seting['ma_src'])
    df['ma'] = GetMa(df['ma_src'], seting['ma_len'], seting['ma_type'])
    df['atr'] = ATR(r, seting['atr_len'], seting['atr_type'])
    df['zhisun'] = 0.0
    if seting['buy']:
        df['h'] = df['High'].rolling(seting['tupo']).max()
        df['l2'] = df['Low'].rolling(seting['pianli']).min()

    if seting['sell']:
        df['l'] = df['Low'].rolling(seting['tupo']).min()
        df['h2'] = df['High'].rolling(seting['pianli']).max()

    df['da'] = 0
    df['xiao'] = 0
    df['buy'] = 0
    # df['pingtime'] = 0
    for i in range(c):
        if i > seting['ma_len']:
            if df['Close'][i] > df['ma'][i] and (df['Close'][i-1] < df['ma'][i-1] or df['da'][i-1]):
                df['da'].values[i] = df['da'][i-1] + 1

            if df['Close'][i] < df['ma'][i] and (df['Close'][i-1] > df['ma'][i-1] or df['xiao'][i-1]):
                df['xiao'].values[i] = df['xiao'][i-1] + 1

    preSide = 0
    preZhisun = 0
    preZhisunBili = 0
    preZhiYingBili = 0

    buy = 0
    sell = 0
    for i in range(c):
        if i > seting['ma_len'] and i+1 < c:
            if seting['buy']:
                #连续多少根 大于 均线之上
                if df['Close'][i] < df['ma'][i] and df['da'][i-1] > seting['pianli']: #and df['Close'][i] > df['l2'][i]
                    df['side'].values[i] = 'BUY'

                    if preSide != 'BUY':
                        preSide = 'BUY'
                        preZhisun = df['Open'][i+1] - seting['atr_mult'] * df['atr'][i]
                        preZhisunBili = GetRoeJia(-seting['buyZhisun'], {'liang': 1, 'jiage': df['Open'][i+1]})
                        preZhiYingBili = GetRoeJia(seting['buyZhiying'], {'liang': 1, 'jiage': df['Open'][i+1]})

                    # if not buy:
                    #     df['pingtime'].values[i] = df['Time'][i] + (df['Time'][1] - df['Time'][0]) * (seting['pingcang'] + 2)
                        # df['pingtime'].values[i] = GetTime(df['pingtime'].values[i], '%Y-%m-%d %H:%M')

                    buy += 1

                elif buy:
                    buy += 1

                if buy > seting['pingcang']+1 or (seting['tupo'] and df['Close'][i] >= df['h'][i-1]):
                    df['close'].values[i] = 'BUY'
                    buy = 0
                    if preSide == "BUY":
                        preSide = 0

                df['buy'].values[i] = buy

            if seting['sell']:
                if df['Close'][i] > df['ma'][i] and df['xiao'][i-1] > seting['pianli']: # and df['Close'][i] < df['h2'][i]
                    df['side'].values[i] = 'SELL'

                    if preSide != 'SELL':
                        preSide = 'SELL'
                        preZhisun = df['Open'][i+1] + seting['atr_mult'] * df['atr'][i]
                        preZhisunBili = GetRoeJia(-seting['sellZhisun'], {'liang': -1, 'jiage': df['Open'][i+1]})
                        preZhiYingBili = GetRoeJia(seting['sellZhiying'], {'liang': -1, 'jiage': df['Open'][i+1]})

                    # if not sell:
                    #     df['pingtime'].values[i] = df['Time'][i] + (df['Time'][1] - df['Time'][0]) * (seting['pingcang'] + 2)
                        # df['pingtime'].values[i] = GetTime(df['pingtime'].values[i], '%Y-%m-%d %H:%M')
                    sell += 1

                elif sell:
                    sell += 1

                if sell > seting['pingcang']+1 or (seting['tupo'] and df['Close'][i] <= df['l'][i-1]):
                    df['close'].values[i] = 'SELL'
                    sell = 0
                    if preSide == "SELL":
                        preSide = 0

            df['zhisun'].values[i] = preZhisun
            if (preSide == 'BUY' and df['Low'][i] <= preZhisun) or (preSide == 'SELL' and df['High'][i] >= preZhisun) or \
               (preSide == 'BUY' and df['Low'][i] <= preZhisunBili) or (preSide == 'SELL' and df['High'][i] >= preZhisunBili) or \
               (preSide == 'BUY' and df['High'][i] >= preZhiYingBili) or (preSide == 'SELL' and df['Low'][i] <= preZhiYingBili):
                preSide = 0
                buy = 0
                sell = 0

    return df

1. 策略原理

原理和Bounce反弹策略很像，区别在于一个逆势 一个顺势
暂时取名叫Sb策略，哈哈

有个坏处是它属于高频超短线策略，需要Maker手续费
Bounce反弹策略就不一样了，手续费再高也能盈利

半年了，每日每夜的研究，走过不少弯路
还好前一个月走回来了策略这条路
金融，Good Bye

2. 回测结果

万2手续费Eth近四个月：

万1手续费Eth近四个月：

万0手续费Eth近四个月：

Eth Eth_Sell Dot Dot_Sell
两个交易对多空双开回测：

万2手续费近2个月：

万0手续费近2个月：

万2手续费近1年：

万0手续费近1年：

统计：

3. 总结

以上仅仅是两个交易对的效果，如果10个交易对呢，2333
然后加上配合市商账号相信日化可以达到5%

一如既往最大回撤控制在30%

1.策略原理

Dca：Dollar cost averaging 美元平均成本

使用均线确定趋势
均线金叉后 买入初始 N% 量
然后确定十条网格线 （网格之间间距越来越大）
每个网格线买入点的量倍投

止盈：持仓成本固定 1.5%
止损：第十条网格价格线的 N%

于普通马丁和网格不同，带有止损不会被套和爆仓

网格线和加仓量计算代码：

seting =  {
    'base_size': 5,                 #初始下单量 %
    'safety_size': 2,                #马丁初始下单 %

    'max_trades': 9,                 #最大交易数
    'wangge_price': 0.4 * 0.01,      #网格间距
    'wangge_price_scale': 1.19,      #网格乘数
    'wangge_volume_scale': 1.8,      #马丁乘数
}

class DcaClass():
    def __init__(self, seting):
        self.close = 0  #初始开仓价格
        self.seting = seting
        self.i = 1

    #参数i为第几条网格线
    def step(self, i):
        pd = self.seting['wangge_price']
        ss = self.seting['wangge_price_scale']

        if i == 1:
            return pd
        if i == 2:
            return pd + pd * ss
        if i == 3:
            return pd + (pd + pd * ss) * ss
        if i == 4:
            return pd + (pd + (pd + pd * ss) * ss) * ss
        if i == 5:
            return pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss
        if i == 6:
            return pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss
        if i == 7:
            return pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss
        if i == 8:
            return pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss
        if i == 9:
            return pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss
        if i == 10:
            return pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss
        return pd

    """网格价格计算"""
    def long_line(self, i, side):
        return self.close - self.close * self.step(i) if side == 'BUY' else self.close + self.close * self.step(i)

    """倍投数量计算"""
    def safety_order_size(self, yuer, i, side):
        ok = yuer * self.seting['safety_size'] / 100 * math.pow(self.seting['wangge_volume_scale'], i-1) #次方根
        return ok if side == 'BUY' else -ok

总结：Ma交叉后使用类似马丁的方法加仓，提高胜率

2.回测结果

1. 策略原理

当收盘价上穿下轨，做多
当收盘价下穿上轨，做空

代码：

seting = {'name': 'BBv3', 'symbol': 'BTCUSDT', 'kTime': '15m', 'bb_len': 7, 'buy_len': 44, 'buy_mult': 2.664, 'sell_len': 20, 'sell_mult': 2.54, 'buy': 1, 'buyZhiying': 12.704, 'buyZhisun': 7.525, 'sell': 1, 'sellZhiying': 6.112, 'sellZhisun': 1.52}

"""
布林带升级版定向策略
"""
def BBv3(r, df, seting):
    df['ma'] = SMA(r, seting['bb_len'], 'Close')

    df['upper'] = df['ma'] + seting['sell_mult'] * talib.STDDEV(df['Close'], timeperiod=seting['sell_len'])
    df['lower'] = df['ma'] - seting['buy_mult'] * talib.STDDEV(df['Close'], timeperiod=seting['buy_len'])

    c = len(df)
    for i in range(c):
        if i > seting['sell_len'] and i+1 < c:
            if df['Close'][i] > df['lower'][i] and df['Close'][i-1] < df['lower'][i-1]: # and df['Close'][i] > df['ma2'][i]
                df['side'].values[i] = 'BUY'

            if df['Close'][i] < df['upper'][i] and df['Close'][i-1] > df['upper'][i-1]: # and df['Close'][i] < df['ma2'][i]
                df['side'].values[i] = 'SELL'

    return df

2.回测结果

BTCUSDT 15m：

1.策略原理

计算Rsi值，再计算Rsi的Ma值，进行相减：Rsi-Ma(Rsi)
再把相减的值进行Ma平滑：Ma(Rsi-Ma(Rsi))

最后的结果 上穿0，开多，下穿0，开空

2. 回测结果

三个交易对组合投资，1hK线：

1.策略原理

开仓条件：Boll开口扩大，中轨往上走，Rsi没有超买，Atr大于前值
平仓条件：Boll开口缩小，中轨往下走

2.回测结果

15mK线，只做多：

1.策略原理

一个很简单的策略
突破上轨，且Rsi没有超卖时做多，价格回归中轨时平仓

代码：

seting = {'name': 'BB', 'symbol': 'ETHUSDT', 'kTime': '15m', 'bb_len': 129, 'bb_mult': 2.259, 'rsi_len': 22, 'rsi_long_min': 15, 'rsi_long_max': 76, 'rsi_short_min': 12, 'rsi_short_max': 74, 'buy': 1, 'buyZhiying': 13.037, 'buyZhisun': 8.014, 'sell': 1, 'sellZhiying': 5.084, 'sellZhisun': 13.086}

"""
布林带策略
"""
def BB(r, df, seting):
    df['ma'] = SMA(r, seting['bb_len'], 'Close')
    df['mult'] = seting['bb_mult'] * talib.STDDEV(df['Close'].values, timeperiod=seting['bb_len'])
    df['upper'] = df['ma'] + df['mult']
    df['lower'] = df['ma'] - df['mult']
    df['rsi'] = talib.RSI(df['Close'].values, timeperiod=14)

    c = len(df)
    for i in range(c):
        if i > seting['bb_len'] and i+1 < c:
            if df['Close'][i] > df['upper'][i] and df['Close'][i-1] < df['upper'][i-1] and\
                df['rsi'][i] >= seting['rsi_long_min'] and df['rsi'][i] <= seting['rsi_long_max']:
                df['side'].values[i] = 'BUY'

            if df['Close'][i] < df['ma'][i] and df['Close'][i-1] > df['ma'][i-1]:
                df['close'].values[i] = 'BUY'

            if df['Close'][i] < df['lower'][i] and df['Close'][i-1] > df['lower'][i-1] and\
                 df['rsi'][i] >= seting['rsi_short_min'] and df['rsi'][i] <= seting['rsi_short_max']:
                df['side'].values[i] = 'SELL'

            if df['Close'][i] > df['ma'][i] and df['Close'][i-1] < df['ma'][i-1]:
                df['close'].values[i] = 'SELL'

    return df

2.回测结果

1.策略原理

很简单的一个策略，只用了DMI一个指标
获得DMI两条线后相减，再把值做平滑处理
值 > 0 且大于上一个值 就做多

DMI指标的计算可以看我发过的ADX指标里面有

代码：

"""
DMI指标策略
"""
def DMI(r, df, seting):
    a, b = DI(r, seting['dmi_len'])
    df['dmi'] = a-b

    if seting['ma_type'] == 'sma':
        df['dmi'] = SMA(df['dmi'].values, seting['ma_len'])

    if seting['ma_type'] == 'ema':
        df['dmi'] = talib.EMA(df['dmi'].values, seting['ma_len'])

    if seting['ma_type'] == 'rma':
        df['dmi'] = RMA(df['dmi'].values, seting['ma_len'])

    c = len(df)
    for i in range(c):
        if i > seting['ma_len'] and i+1 < c:
            if df['dmi'][i] > 0 and df['dmi'][i] > df['dmi'][i-1]:
                df['side'].values[i] = 'BUY'

            if df['dmi'][i] < 0 and df['dmi'][i] < df['dmi'][i-1]:
                df['side'].values[i] = 'SELL'

    return df

2.回测结果

15mk线 2021年：

1.策略原理

这是基于 p 信号构建交易策略的示例。 p 信号表示 Kolmogorov 概率空间中 交易对的 D 帧系统状态的熵。

TradingView完整源码：

strategy("P-Signal Strategy:", precision = 3)
//
// Parameters and const of P-Signal.
//
nIntr = input(title = "Number of Bars", type = input.integer, defval = 9, minval = 4, maxval = 100, group = "Parameters of observation.")
bSmooth = input(title = "Smoothing", type = input.bool,  defval = true, group = "Parameters of observation.")
// 
// Horner's method for the error (Gauss) & P-Signal functions.
//
fErf(x) =>
    nT = 1.0/(1.0 + 0.5*abs(x))
    nAns = 1.0 - nT*exp(-x*x - 1.26551223 + 
     nT*( 1.00002368 + nT*( 0.37409196 + nT*( 0.09678418 + 
     nT*(-0.18628806 + nT*( 0.27886807 + nT*(-1.13520398 + 
     nT*( 1.48851587 + nT*(-0.82215223 + nT*( 0.17087277 ))))))))))
    x >= 0 ? nAns : -nAns

fPSignal(ser, int) => 
    nStDev = stdev(ser, int)
    nSma = sma(ser, int)
    fErf(nStDev > 0 ? nSma/nStDev/sqrt(2) : 1.0)
//
// Signals on Set of Frames.
//

nPSignal = fPSignal(change(ohlc4), nIntr)
nPSignal := if (bSmooth) 
    sma(nPSignal, nIntr)
ndPSignal = sign(nPSignal[0] - nPSignal[1])
//
// P-Signal plotting. 
//
hline(+1.0, color = color.new(color.orange,70), linestyle = hline.style_dotted)
hline(-1.0, color = color.new(color.orange,70), linestyle = hline.style_dotted)
plot(nPSignal, color = nPSignal > nPSignal[1] ? color.green : color.red, style = plot.style_line)
//
// Strategy "A penny saved is a penny earnd." Caution with short!
//
strategy.entry("long", strategy.long, when = nPSignal < 0 and ndPSignal > 0)
strategy.close("long", when = nPSignal > 0 and ndPSignal < 0)

Python实现：

2. 回测结果

K线15m 手续费万4% MA周期60 止盈30% 止损6.6%
2021年:

1. 策略原理

该策略为震荡策略，
顺大势逆小势，大势为多，那么每当在底部就开多，到高处平多。做空反之
亏损的原因为大势逆转

这个策略好处在于一套参数可以适应最近五年
并且因为是震荡策略，不用苦逼的等趋势

还是有优化的空间，这个出场太早，无法吃到趋势
然后这个策略组合投资会是什么情况呢？
睡了明天搞

2. 回测结果

1.策略原理

原理用K的值，再进行趋势过滤平滑，适合分钟K线，2m 5m 15m
计算太过复杂，实现也弄了挺久，直接放代码

2. 回测结果

2021 5m 多空

2020 5m 多

2021 15m 多

2020 15m 多

2020年的回测没有参数调优

1. 策略原理

Ema价格线 与 量加权Ema线交叉

量加权Ema线计算:
(过去N根 价格 * 量) 总和 除以 (过去N根 量) 总和
得出的值再计算Ema

核心代码：

2. 回测结果

ETHUSDT 15m 2020-2021两年

1.原理

之前我做的策略和回测都是单个交易对交易，那么我们可不可以多个交易对同时进行交易呢？

下面找了八个交易对，然后使用VWAP+Fibo 反转策略： https://sumubai.cc/post/40
一起交易

因为杠杠的存在，我们可以每个交易对都满仓
比如每个交易对买一份，共买8份，杠杠开8倍即可

单个交易对最大回撤是30%, 但是组合在一起后最大回撤没有出现30%+30%=60%的情况
因为这个交易对出现最大回撤了，但是其他交易对这个时间都赚钱了

唯一的风险就是所有交易对同时亏钱，这个就需要实盘运行时加一个风控管理
控制账户最大浮亏

2. 回测结果

2021年 不复利

10月-12月 不复利

复利回测就没必要看了，好几个亿

1.策略原理

VWAP：交易量加权平均线，这里周期用的一周，也就是每周一早上八点重置
Fibo：斐波那契黄金分割线

根据VWAP线+Fibo比例，设置四条轨道，突破上轨后做空，突破下轨后做多
价格回到VWAP线平仓

2.回测结果

PS：参数没有做最优化

ETH 今年回测结果：

BTC 今年回测结果:

3. 结语

交易次数低，收益也过少，不如趋势策略，不过胜在胜率高
并且全品种通用，期货之类也是

可以考虑加止盈止损调参

1. 模型选择

LGB全名LigthGBM是boosting集合模型中的新进成员，它和xgboost一样是对GBDT的高效实现，很多方面会比xgboost表现的更为优秀。原理上它和GBDT及xgboot类似，都采用损失函数的负梯度作为当前决策树的残差近似值，去拟合新的决策树。

一开始选择的是LSTM，不过经过各种折腾，对我这个新手小白都不好解决欠拟合和过拟合
参考了以下文章后选择了LGB
文章：

1. 送你一份年化100%+的策略
2. LightGBM模型简单预测股票涨跌情况
3. LightGBM（lgb）介绍

2. 数据来源

我这边选择的是爬取币安给出的2020年至今的几大主流币历史合约K线数据，周期为5m
主流币选择，看总市值排行选择出来的币：
'BTCUSDT',
'ETHUSDT',
'LTCUSDT',
'BNBUSDT',
'XMRUSDT',
'XRPUSDT',
'XTZUSDT',
'ADAUSDT',
'BCHUSDT',

3. 模型问题

LGB可以解决多分类问题、线性问题、二分类问题，我这边选择的是二分类问题
也就是下一根收盘价大于这一根收盘价标记为1，反之为0，让LGB去预测分类

代码：

features['label'] = ((features['next_close'] / features['Close'] - 1) > 0)
features['label'] = features['label'].astype('int')

4. 模型特征

在我每天尝试几个指标，尝试了几十个指标（说多了都是泪，每个指标Talib没有的得自己实现，实现后再慢慢调参）：

最后组合出来了以下做为特征：
'close_tf',
'vol_tf',
'high_tf',
'low_tf',
'hlc_tf',
'zhenfu',
'macd',
'adx',
'rsi',
'dpo',

5. 数据处理

处理就是把缺少数据的行给删除
我还做了以下尝试，效果都没优化：

1. 删除涨幅小的数据，删除后预测效果更差了
2. 删除inf值的数据，删除后预测效果更差了

LGB不像神经网络需要对异常值很敏感，所以就不处理其他的了

然后再划分出训练集和测试集
训练集：20200101-20210601
测试集：20210601-20211101

6. 模型训练

代码：

import lightgbm as lgb
param = {
     'num_leaves': 31,
     'learning_rate': 0.06,
     "boosting": "gbdt",
     "metric": 'auc',
     'device': 'gpu',
     "verbosity": -1,
}

trn_data = lgb.Dataset(trn, label=trn_label)
val_data = lgb.Dataset(val, label=val_label)
num_round = 500
#clf = lgb.train(param, trn_data, num_round, valid_sets=[trn_data, val_data])
clf = lgb.train(param, trn_data, num_round)
#clf.save_model("v6_8-25.txt")
test_lgb = clf.predict(val, num_iteration=clf.best_iteration)
pd.DataFrame({
        'column': feature_col,
        'importance': clf.feature_importance(),
    }).sort_values(by='importance', ascending=False)

参数为第一篇文章所给的参数，在这里感谢下他的分享

训练结果：

正确率为52.2%

6. 模型回测

模型训练完，那么就让他在测试集表现一下如何

回测设置：双边万4%，杠杠5，不复利

因为手续费的问题
这里设置的为预测下一根K线涨跌概率大于63%才开仓
要不然会赔的裤衩子都不剩，如果有手续费为0的账号那么55%概率就可以开仓了
退出条件为5m走完就平仓

回测结果：

7. 结语

我做量化以来踩过3个坑，其中这个机器学习就占了两个

1. 我做了一个策略，回测今年每个月都有一次30%以上的大回撤并且2020年无法盈利，还是让它上线了，前面翻倍，后面本金腰斩
2. 一开始做这个机器学习，测试集只用了80天，年初也无法盈利，导致过拟合本金腰斩
3. 最后呢 机器学习终于做出来了，杠杠开太大25倍，本金腰斩，哈哈哈哈

唯一没赔钱的一次还是靠爬交易所公告，找即将上线的新币梭哈的

因为水平有限，我现在做量化暂时不用机器学习这种方式了
原因是我的水平只能做类似黑盒测试，无法了解他的运行原理，导致我无法再优化它

不要灰心，这个模型到现在11月20日也是盈利的状态，什么时候失效就不知道了

并且做机器学习的这几个月让我知道了很多指标的计算方式和使用方式
可以尝试根据自己对指标的认知做策略了，策略稳定盈利后再来剖析机器学习

最后给打算接触的一些建议：

1. 不要尝试预测价格，否则最优结果永远是上一根K线收盘价，预测涨跌、收益率
2. 初学者做这个很难分辨策略是不是过拟合了（大佬除外）
3. 可以尝试预测高频，高频数据的拟合更加容易
4. 也可以去试试NLP自然语言处理，爬各种动态新闻，先行一步入场，做庄家肚子里的蛔虫