Estratégias de equilíbrio dinâmico baseadas em moeda digital

Primeira, resumo

O mentor de Warren Buffett, Benjamin Graham, mencionou um modelo de negociação de equidades e títulos com equilíbrio dinâmico em seu livro "The Smarter Investor".O modelo de negociação é muito simples:

• Investir 50% dos seus fundos em fundos de ações e os restantes 50% em fundos de títulos; ou seja, ações e títulos representam metade.
• O equilíbrio dos ativos é feito de uma vez por ano, em intervalos fixos ou com mudanças no mercado, para que a proporção de ativos de ações e ativos de títulos volte ao nível inicial de 1:1. É a lógica de toda a estratégia, incluindo quando comprar e quanto comprar.

O princípio do equilíbrio dinâmico

Nesse método, a volatilidade dos fundos de títulos é pequena, muito menor do que a volatilidade das ações, então as ações são aqui consideradas como um "parâmetro de referência", ou seja, as ações são usadas para medir se as ações ganham muito ou pouco.

Se o preço da ação subir, o valor de mercado da ação será maior do que o valor de mercado da obrigação. Quando o rácio de valor da ação exceder o limite estabelecido, o posicionamento total será reajustado, as ações serão vendidas e as obrigações serão compradas.

Em contrapartida, a queda do preço das ações faz com que o valor de mercado das ações seja menor do que o valor de mercado das obrigações, e quando o rácio de valor das ações excede o limite estabelecido, o posicionamento total é reajustado, com a compra de ações e a venda de obrigações, tornando o rácio de valor das ações e das obrigações de volta ao seu valor inicial de 1:1.

Assim, o equilíbrio dinâmico entre a proporção de ações e de títulos é suficiente para desfrutar dos frutos do crescimento das ações e reduzir a volatilidade dos ativos. Como pioneiro do investimento em valor, Graham nos deu uma ótima idéia.

Três, lógica estratégica.

Estratégias de equilíbrio dinâmico em ativos blockchain BTC

Lógica estratégica

• De acordo com o valor atual do BTC, o saldo da conta é reservado em ¥ 5000 em dinheiro e 0,1 BTC, ou seja, a proporção inicial de dinheiro e valor de mercado do BTC é de 1:1.
• Se o preço do BTC subir para ¥6000, ou seja, o valor de mercado do BTC for maior do que o saldo da conta, e o diferencial entre eles exceder o limite definido, venda (<= 6000-5000) /6000/2 moedas.
• Se o preço do BTC cair para ¥ 4000, ou seja, o valor de mercado do BTC é menor do que o saldo da conta, e o diferencial entre eles é maior do que o limiar definido, compre ¥ 5000-4000 / 4000 / 2.

Assim, independentemente de BTC ser valorizado ou depreciado, o saldo da conta é sempre mantido dinâmico e igual ao valor de mercado do BTC. Se o BTC for depreciado, você compra um pouco e vende mais, como se fosse normal.

Quatro, um quadro estratégico

Então, como é que isso pode ser feito com código? Vamos começar por um quadro estratégico, usando o inventor como exemplo de plataforma de negociação quantitativa:

// 撤单函数
function CancelPendingOrders() {}

// 下单函数
function onTick() {}

// 主函数
function main() {
    // 过滤非重要信息
    SetErrorFilter("GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout");
    while (true) { // 轮询模式
        if (onTick()) { // 执行 onTick 函数
            CancelPendingOrders(); // 取消未成交的挂单
            Log(_C(exchange.GetAccount)); // 打印当前账户信息
        }
        Sleep(LoopInterval * 1000); // 休眠
    }
}

A estrutura de políticas é simples, com uma função principal, uma função sub-função onTick, uma função CancelPendingOrders e os parâmetros necessários.

Quinto, módulo de subdivisão

// 下单函数
function onTick() {
    var acc = _C(exchange.GetAccount); // 获取账户信息
    var ticker = _C(exchange.GetTicker); // 获取 Tick 数据
    var spread = ticker.Sell - ticker.Buy; // 获取 Tick 数据的买卖价差
    // 账户余额与当前持仓价值的差值的 0.5倍
    var diffAsset = (acc.Balance - (acc.Stocks * ticker.Sell)) / 2;
    var ratio = diffAsset / acc.Balance; // diffAsset / 账户余额
    LogStatus('ratio:', ratio, _D()); // 打印 ratio和当前时间
    if (Math.abs(ratio) < threshold) { // 如果 ratio的绝对值小于指定阈值
        return false; // 返回 false
    }
    if (ratio > 0) { // 如果 ratio大于 0
        var buyPrice = _N(ticker.Sell + spread, ZPrecision); // 计算下单价格
        var buyAmount = _N(diffAsset / buyPrice, XPrecision); // 计算下单量
        if (buyAmount < MinStock) { // 如果下单量小于最小交易量
            return false; // 返回 false
        }
        exchange.Buy(buyPrice, buyAmount, diffAsset, ratio); // 买入下单
    } else {
        var sellPrice = _N(ticker.Buy - spread, ZPrecision); // 计算下单价格
        var sellAmount = _N(-diffAsset / sellPrice, XPrecision); // 计算下单量
        if (sellAmount < MinStock) { // 如果下单量小于最小交易量
            return false; // 返回 false
        }
        exchange.Sell(sellPrice, sellAmount, diffAsset, ratio); // 卖出下单
    }
    return true; // 返回 true
}

A lógica de transação abaixo é clara, todas as observações estão escritas no código, pode-se clicar na imagem para ver em maior.

Os principais processos são os seguintes:

• Aceder às informações da conta.
• Obtenha dados do Tick.
• Computação de preços de venda de dados Tick.
• A diferença entre o saldo da conta e o preço de mercado do BTC é calculada.
• Calcule as condições de compra e venda, o preço da encomenda e a quantidade da encomenda.
• O que é o que você está fazendo?

6 - Modulo de retirada de pedidos

// 撤单函数
function CancelPendingOrders() {
    Sleep(1000); // 休眠 1秒
    var ret = false;
    while (true) {
        var orders = null;
        // 持续获取未成交订单数组，如果返回异常，则继续获取
        while (!(orders = exchange.GetOrders())) {
            Sleep(1000); // 休眠 1秒
        }
        if (orders.length == 0) { // 如果订单数组为空
            return ret; // 返回撤单状态
        }
        for (var j = 0; j < orders.length; j++) { // 遍历未成交订单数组
            exchange.CancelOrder(orders[j].Id); // 依次取消未成交订单
            ret = true;
            if (j < (orders.length - 1)) {
                Sleep(1000); // 休眠 1秒
            }
        }
    }
}

A partir de agora, o processo de remoção dos módulos será mais simples, com os seguintes passos:

• A primeira coisa que você precisa fazer é esperar um segundo antes de retirar o dinheiro, em cada bolsa, você sabe.
• Continuar a obter a matriz de pedidos pendentes e continuar a obter se retornar uma anomalia.
• Se a matriz de pedidos pendentes estiver vazia, retornará imediatamente ao estado de retirada.
• Se houver uma encomenda pendente, percorra toda a matriz e retire-a em ordem de número.

7. Código de código da estratégia completa

// 回测环境
/*backtest
start: 2018-01-01 00:00:00
end: 2018-08-01 11:00:00
period: 1m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/



// 撤单函数
function CancelPendingOrders() {
    Sleep(1000); // 休眠 1秒
    var ret = false;
    while (true) {
        var orders = null;
        // 持续获取未成交订单数组，如果返回异常，则继续获取
        while (!(orders = exchange.GetOrders())) {
            Sleep(1000); // 休眠 1秒
        }
        if (orders.length == 0) { // 如果订单数组为空
            return ret; // 返回撤单状态
        }
        for (var j = 0; j < orders.length; j++) { // 遍历未成交订单数组
            exchange.CancelOrder(orders[j].Id); // 依次取消未成交订单
            ret = true;
            if (j < (orders.length - 1)) {
                Sleep(1000); // 休眠 1秒
            }
        }
    }
}

// 下单函数
function onTick() {
    var acc = _C(exchange.GetAccount); // 获取账户信息
    var ticker = _C(exchange.GetTicker); // 获取 Tick 数据
    var spread = ticker.Sell - ticker.Buy; // 获取 Tick 数据的买卖价差
    // 账户余额与当前持仓价值的差值的 0.5倍
    var diffAsset = (acc.Balance - (acc.Stocks * ticker.Sell)) / 2;
    var ratio = diffAsset / acc.Balance; // diffAsset / 账户余额
    LogStatus('ratio:', ratio, _D()); // 打印 ratio和当前时间
    if (Math.abs(ratio) < threshold) { // 如果 ratio的绝对值小于指定阈值
        return false; // 返回 false
    }
    if (ratio > 0) { // 如果 ratio大于 0
        var buyPrice = _N(ticker.Sell + spread, ZPrecision); // 计算下单价格
        var buyAmount = _N(diffAsset / buyPrice, XPrecision); // 计算下单量
        if (buyAmount < MinStock) { // 如果下单量小于最小交易量
            return false; // 返回 false
        }
        exchange.Buy(buyPrice, buyAmount, diffAsset, ratio); // 买入下单
    } else {
        var sellPrice = _N(ticker.Buy - spread, ZPrecision); // 计算下单价格
        var sellAmount = _N(-diffAsset / sellPrice, XPrecision); // 计算下单量
        if (sellAmount < MinStock) { // 如果下单量小于最小交易量
            return false; // 返回 false
        }
        exchange.Sell(sellPrice, sellAmount, diffAsset, ratio); // 卖出下单
    }
    return true; // 返回 true
}

// 主函数
function main() {
    // 过滤非重要信息
    SetErrorFilter("GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout");
    while (true) { // 轮询模式
        if (onTick()) { // 执行 onTick 函数
            CancelPendingOrders(); // 取消未成交的挂单
            Log(_C(exchange.GetAccount)); // 打印当前账户信息
        }
        Sleep(LoopInterval * 1000); // 休眠
    }
}

Parâmetros externos

8. Retrospecção estratégica

Em seguida, vamos testar essa simples estratégia de equilíbrio dinâmico para ver se funciona. Abaixo está um retrospecto dos dados históricos do BTC, apenas para referência.

Revisão do ambiente

Reavaliação de desempenho

Curva de retraso

Aqui está outro gráfico do movimento do preço do BTC no mesmo período.

No período de revisão, o BTC tem caído por 8 meses, até mais de 70%, o que faz com que muitos investidores perdam a confiança nos ativos blockchain. A estratégia acumula ganhos de até 160% e risco de ganhos anuais de mais de 5%.

9 - Obter o código fonte da estratégia

O código-fonte da estratégia está disponível no site do inventor.https://www.fmz.com/strategy/110545Não é necessário configurar o teste online direto.

10. Resumo

Esta estratégia de equilíbrio dinâmico, com apenas um parâmetro central (o limiar de valor), é um método de investimento muito simples, que não busca ganhos excessivos, mas ganhos sólidos. Ao contrário da estratégia de tendência, a estratégia de equilíbrio dinâmico é contraditória. A estratégia de equilíbrio dinâmico é exatamente o contrário, diminuindo a temperatura do estoque quando o mercado está quente e aumentando a volatilidade do estoque quando o mercado está frio, algo parecido com a regulação macroeconômica.

Na verdade, a estratégia de equilíbrio dinâmico é uma estratégia que adere ao conceito de imprevisão de preços, mas também capta as flutuações de preços. O núcleo fundamental da estratégia de equilíbrio dinâmico é definir e ajustar a proporção de distribuição de ativos e desencadear um limite.

Para terminar, vamos terminar com uma famosa citação de Benjamin Graham no seu livro The Brilliant Investor:O mercado de ações não é um "peso" para medir o valor com precisão, mas sim uma "máquina de votação", onde as decisões de inúmeras pessoas são uma mistura de racionalidade e emoção, muitas vezes muito distantes entre as escolhas e as avaliações de valor racionais. O segredo para investir é investir quando o preço está muito abaixo do valor intrínseco e acreditar que a tendência do mercado vai se recuperar.Benjamin Graham é um investidor inteligente.