Estrategia dinámica de creación de posición

El autor:¿ Qué pasa?, Fecha: 2024-02-20 14:16:30
Las etiquetas:

Resumen general

La idea principal de esta estrategia es construir dinámicamente una posición basada en señales del sistema en un mercado alcista para controlar los riesgos y obtener un precio de entrada promedio más bajo.

Estrategia lógica

La estrategia primero establece el capital inicial y el porcentaje de DCA. Al cierre de cada barra, calcula un porcentaje ajustado basado en el cambio de precio. Si el precio sube, reduce el porcentaje. Si el precio cae, aumenta el porcentaje. Esto permite agregar a la posición a precios más bajos. Luego calcula el tamaño del pedido basado en el porcentaje ajustado y el capital restante. En cada barra de cierre, coloca órdenes para construir la posición hasta que se use el capital inicial.

Por lo tanto, puede controlar los riesgos y obtener un precio de entrada promedio más bajo durante la acción de precios fluctuantes.

Análisis de ventajas

La estrategia tiene las siguientes ventajas:

Puede escalar dinámicamente en la posición, aumentando la asignación en las caídas y disminuyendo la asignación en los altibajos para controlar los riesgos.
Obtiene un precio de entrada promedio más bajo en comparación con el precio mediano, lo que permite un mayor potencial de ganancia.
Se ajusta a los mercados alcistas con volatilidad para mejores ratios riesgo-recompensa.
Permite establecer previamente el capital inicial y el porcentaje de DCA para controlar el riesgo de dimensionamiento de la posición.
Proporciona estadísticas sobre el precio medio de entrada y el precio mediano para un juicio claro de la calidad de entrada.

Análisis de riesgos

También hay algunos riesgos:

En los mercados en caída, seguirá aumentando la posición, lo que llevará a fuertes pérdidas.
Si el precio sube rápidamente, el escalado disminuirá, posiblemente perdiendo gran parte del repunte.
La configuración inadecuada de los parámetros también plantea peligros.

Direcciones de optimización

Algunas maneras de optimizar la estrategia:

Agregue la lógica de stop loss para dejar de escalar en las ventas pesadas.
Adaptar dinámicamente el porcentaje de DCA en función de la volatilidad u otras métricas.
Incorporar modelos de aprendizaje automático para predecir los precios y guiar las decisiones de escala.
Combinar otros indicadores para identificar cambios en la estructura del mercado para escalar los puntos de salida.
Añadir reglas de gestión de capital a las órdenes de tamaño dinámico basadas en los valores de la cuenta.

Conclusión

Esta es una estrategia de escalado de posición dinámica muy práctica. Ajusta de manera flexible el tamaño de la posición en función de las fluctuaciones de precios para lograr buenas entradas promedio en los mercados alcistas, al tiempo que restringe el riesgo a través de parámetros configurables. Combinarlo con otros indicadores o modelos puede mejorar aún más su rendimiento. Es adecuado para los inversores que buscan ganancias a largo plazo.

/*backtest
start: 2024-01-20 00:00:00
end: 2024-02-19 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RWCS_LTD

//@version=5
strategy("DCA IN Calculator {RWCS}", overlay=true, pyramiding=999, default_qty_type=strategy.cash, initial_capital=10000, commission_value=0.02)

// User inputs
backtestStartDate = input(timestamp("1 Jan 2024"), 
     title="Start Date", group="Backtest Time Period",
     tooltip="This start date is in the time zone of the exchange " + 
     "where the chart's instrument trades. It doesn't use the time " + 
     "zone of the chart or of your computer.")
start_date = true
starting_capital = input.float(defval=5000, title="Starting Capital")
dca_allocation_percentage = input.int(defval=10, title="DCA Allocation Percentage")

// Calculate DCA allocation based on price change
price_change_percentage = ((close - close[1]) / close[1]) * 100
adjusted_allocation_percentage = close > close[1] ? dca_allocation_percentage - price_change_percentage : dca_allocation_percentage + price_change_percentage // If price action is negative, increase allocations
adjusted_allocation_percentage1 = dca_allocation_percentage - price_change_percentage // If price action is positive, reduce allocations

// Calculate order size based on adjusted allocation percentage
order_size = (adjusted_allocation_percentage / 100) * starting_capital

// Track remaining capital
var remaining_capital = starting_capital

// Long on the close of every bar
if true
    // Ensure the order size doesn't exceed remaining capital or adjusted allocation
    order_size := math.min(order_size, remaining_capital, adjusted_allocation_percentage / 100 * starting_capital)
    // Ensure order size is not negative
    order_size := math.max(order_size, 0)
    
    strategy.entry("DCA", strategy.long, qty = order_size)
    remaining_capital := remaining_capital - order_size

// Plot average entry price
var float total_entry_price = 0.0
var int total_signals = 0

if start_date
    total_entry_price := total_entry_price + close
    total_signals := total_signals + 1

avg_entry_price = total_entry_price / total_signals

// Calculate and plot median price
var float median_price = na

if start_date
    var float sum_prices = 0.0
    var int num_prices = 0
    
    for i = 0 to bar_index
        if (time[i] >= backtestStartDate)
            sum_prices := sum_prices + close[i]
            num_prices := num_prices + 1
    
    median_price := sum_prices / num_prices

// Reset variables at the start of each day
if (dayofweek != dayofweek[1])
    total_entry_price := 0.0
    total_signals := 0

//table colors
borders_col = color.new(color.black, 90)
top_row_col = color.new(color.gray, 90)
size = input.string(defval='Normal', options=['Tiny', 'Small', 'Normal', 'Large'], title='Table size', inline='design', group='Table Design')
table_size = size == 'Tiny' ? size.tiny : size == 'Small' ? size.small : size == 'Normal' ? size.normal : size == 'Large' ? size.large : na

var tablee = table.new(position=position.top_right, columns=2, rows=3, frame_color=borders_col, frame_width=4, border_color=borders_col, border_width=4)

table.cell(tablee, 0, 0, "Average Entry Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 0, str.tostring(avg_entry_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 1, "Median Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 1, str.tostring(median_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 2, "Remaining Capital", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 2, str.tostring(remaining_capital, '#.##'), text_color=color.white, text_size=table_size)

Más.