সরিষার ফসল কাটার কৌশলগত বিশ্লেষণ (১)

সরিষার ফসল কাটার কৌশল বিশ্লেষণ

সাম্প্রতিক উদ্ভাবকগণের পরিমাণগত উইকিমিডিয়া গ্রুপ আলোচনাprint moneyরোবট, একটি খুব পুরাতন কৌশল আবারও উন্মুক্ত দর্শকদের দৃষ্টিভঙ্গিতে ফিরে এসেছেঃসরিষার ফসল কাটার যন্ত্র。 print moneyরবোটিক ট্রেডিং নীতিগুলি সরিষা কাটার কৌশলগুলি থেকে উদ্ভূত হয়েছিল এবং সে সময় সরিষা কাটার কৌশলগুলির জন্য খুব বেশি পরিষ্কার বা বুঝতে পারেনি বলে নিজেকে দোষারোপ করেছিল।OKCoin রোপণ করুন◄ এটি উদ্ভাবকদের প্ল্যাটফর্মের ক্যোয়ারিটি ট্রান্সপোর্টেড ক্যাপাসিটার কৌশল বিশ্লেষণ এবং কৌশলটির ধারণাগুলি বের করার জন্য ব্যবহারকারীদের শেখার জন্য। এই নিবন্ধে আমরা কৌশলগত চিন্তাভাবনা, উদ্দেশ্য ইত্যাদির স্তর থেকে বিশ্লেষণ করেছি, যতটা সম্ভব প্রোগ্রামিং সম্পর্কিত ক্লান্তিকর বিষয়বস্তু হ্রাস করার চেষ্টা করছি।

[OKCoin Transplanting Cabbage Harvesters] কৌশল উৎস কোডঃ

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {Asks:[], Bids:[]}
    self.prices = []
    self.tradeOrderId = 0
    self.p = 0.5
    self.account = null
    self.preCalc = 0
    self.preNet = 0

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }
    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        self.balanceAccount()
        
        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct
        var bull = false
        var bear = false
        var tradeAmount = 0
        if (self.account) {
            LogStatus(self.account, 'Tick:', self.numTick, ', lastPrice:', self.prices[self.prices.length-1], ', burstPrice: ', burstPrice)
        }
        
        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }
        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8
        }
        
        if (self.numTick < 10) {
            tradeAmount *= 0.8
        }
        
        if ((!bull && !bear) || tradeAmount < MinStock) {
            return
        }
        var tradePrice = bull ? self.bidPrice : self.askPrice
        while (tradeAmount >= MinStock) {
            var orderId = bull ? exchange.Buy(self.bidPrice, tradeAmount) : exchange.Sell(self.askPrice, tradeAmount)
            Sleep(200)
            if (orderId) {
                self.tradeOrderId = orderId
                var order = null
                while (true) {
                    order = exchange.GetOrder(orderId)
                    if (order) {
                        if (order.Status == ORDER_STATE_PENDING) {
                            exchange.CancelOrder(orderId)
                            Sleep(200)
                        } else {
                            break
                        }
                    }
                }
                self.tradeOrderId = 0
                tradeAmount -= order.DealAmount
                tradeAmount *= 0.9
                if (order.Status == ORDER_STATE_CANCELED) {
                    self.updateOrderBook()
                    while (bull && self.bidPrice - tradePrice > 0.1) {
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }
            }
        }
        self.numTick = 0
    }
    return self
}

function main() {
    var reaper = LeeksReaper()
    while (true) {
        reaper.poll()
        Sleep(TickInterval)
    }
}

কৌশলগত বিবরণী

সাধারণভাবে একটি কৌশল শেখার জন্য, যখন আপনি এটি পড়েন, তখন প্রথমে পুরো প্রোগ্রামের কাঠামোটি দেখুন। এই কৌশল কোডটি খুব বেশি নয়, কোডের 200 টিরও কম লাইন রয়েছে, এটি খুব পাতলা বলে মনে করা যায় এবং মূল সংস্করণের জন্য কৌশল পুনরুদ্ধারের উচ্চতর মাত্রা রয়েছে, মূলত একই।main()ফাংশনটি শুরু হয়, পলিসির কোড জুড়ে,main()এটি একটি নামকLeeksReaper()এই ফাংশনটিLeeksReaper()ফাংশনটিও খুব ভালভাবে বোঝা যায়, যা কেবল একটি শাকসব্জী হার্ভারের কৌশলগত লজিকাল মডিউল (একটি বস্তু) হিসাবে বোঝা যায়।LeeksReaper()এটি একটি সরিষার ফসল কাটার ট্রেডিং লজিক তৈরির জন্য দায়ী।

কীওয়ার্ডঃ

• কৌশলmainফাংশনের প্রথম লাইনঃvar reaper = LeeksReaper()কোডটি একটি স্থানীয় ভেরিয়েবল ঘোষণা করেreaper, তারপর LeeksReaper () ফাংশনটি কল করে একটি কৌশলগত লজিক্যাল অবজেক্ট তৈরি করে, যা একটি মান প্রদান করেreaper。

• কৌশলmainফাংশনটি হলঃ

  while (true) {
      reaper.poll()
      Sleep(TickInterval)
  }
  

  প্রবেশ করুনwhileমৃত্যুর চক্র, অবিরাম সম্পাদনreaperবস্তুর প্রক্রিয়াকরণ ফাংশনpoll()，poll()ফাংশনটি হ'ল লেনদেনের কৌশলটির মূল যুক্তি, এবং পুরো কৌশল প্রক্রিয়াটি ক্রমাগত লেনদেনের কার্য সম্পাদনের যুক্তি শুরু করে। এবংSleep(TickInterval)এই লাইনটি খুব ভালভাবে বোঝা যায় যে এটি প্রতিটি সামগ্রিক লেনদেনের লজিক চালানোর পরে বিরতি সময় নিয়ন্ত্রণ করার জন্য, যার উদ্দেশ্য হল লেনদেনের লজিকের ঘূর্ণন ফ্রিকোয়েন্সি নিয়ন্ত্রণ করা।

অ্যানালিসিসLeeksReaper()গঠন ফাংশন

দেখোLeeksReaper()কিভাবে ফাংশন একটি কৌশলগত লজিক্যাল অবজেক্ট গঠন করে?

LeeksReaper()ফাংশন শুরু হয়, একটি ফাঁকা বস্তু ঘোষণা করে,var self = {},LeeksReaper()ফাংশনটি কার্যকর করার সময় ধীরে ধীরে এই ফাঁকা বস্তুর উপর কিছু পদ্ধতি, বৈশিষ্ট্য যোগ করা হয়, অবশেষে বস্তুর নির্মাণ সম্পন্ন হয়, এবং অবশেষে এই বস্তুর ফিরে ((যেমনmain()ফাংশনের ভিতরেvar reaper = LeeksReaper()এই ধাপে, ফিরে আসা বস্তুর মান দেওয়া হয়reaper）。

দাওselfবস্তুর বৈশিষ্ট্য যোগ করুন

এখন আসুনselfঅনেকগুলি বৈশিষ্ট্য যুক্ত করা হয়েছে, আমি নীচে প্রতিটি বৈশিষ্ট্য বর্ণনা করেছি, যা দ্রুত এই বৈশিষ্ট্যগুলি, ভেরিয়েবলগুলির ব্যবহার, উদ্দেশ্য এবং কৌশলগুলি বুঝতে সহায়তা করে, যাতে কোডের এই ময়লাটি দেখতে না হয়।

    self.numTick = 0         # 用来记录poll函数调用时未触发交易的次数，当触发下单并且下单逻辑执行完时，self.numTick重置为0
    self.lastTradeId = 0     # 交易市场已经成交的订单交易记录ID，这个变量记录市场当前最新的成交记录ID
    self.vol = 0             # 通过加权平均计算之后的市场每次考察时成交量参考（每次循环获取一次市场行情数据，可以理解为考察了行情一次）
    self.askPrice = 0        # 卖单提单价格，可以理解为策略通过计算后将要挂卖单的价格
    self.bidPrice = 0        # 买单提单价格
    self.orderBook = {Asks:[], Bids:[]}    # 记录当前获取的订单薄数据，即深度数据（卖一...卖n,买一...买n）
    self.prices = []                       # 一个数组，记录订单薄中前三档加权平均计算之后的时间序列上的价格，简单说就是每次储存计算得到的订单薄前三档加权平均价格，放在一个数组中，用于后续策略交易信号参考，所以该变量名是prices，复数形式，表示一组价格
    self.tradeOrderId = 0    # 记录当前提单下单后的订单ID
    self.p = 0.5             # 仓位比重，币的价值正好占总资产价值的一半时，该值为0.5，即平衡状态
    self.account = null      # 记录账户资产数据，由GetAccount()函数返回数据
    self.preCalc = 0         # 记录最近一次计算收益时的时间戳，单位毫秒，用于控制收益计算部分代码触发执行的频率
    self.preNet = 0          # 记录当前收益数值

দাওselfবস্তু যোগ করার পদ্ধতি

এবং তারপর আপনি self এ এই বৈশিষ্ট্যগুলো যোগ করলে, তারপর আপনি self কে এই বৈশিষ্ট্যগুলো দিতে শুরু করবেন।selfঅবজেক্টের পদ্ধতি যোগ করা, যাতে এই অবজেক্টটি কিছু কাজ করতে পারে, কিছু বৈশিষ্ট্য রয়েছে।

প্রথম যোগ করা ফাংশনঃ

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)  # 调用FMZ封装的接口GetTrades，获取当前最新的市场成交数据
        if (self.prices.length == 0) {       # 当self.prices.length == 0时，需要给self.prices数组填充数值，只有策略启动运行时才会触发
            while (trades.length == 0) {     # 如果近期市场上没有更新的成交记录，这个while循环会一直执行，直到有最新成交数据，更新trades变量
                trades = trades.concat(_C(exchange.GetTrades))   # concat 是JS数组类型的一个方法，用来拼接两个数组，这里就是把“trades”数组和“_C(exchange.GetTrades)”返回的数组数据拼接成一个数组
            }
            for (var i = 0; i < 15; i++) {   # 给self.prices填充数据，填充15个最新成交价格
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {  # _.reduce 函数迭代计算，累计最新成交记录的成交量
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }

updateTradesএই ফাংশনটির কাজ হল সর্বশেষতম বাজার লেনদেনের তথ্য সংগ্রহ করা, এবং এর উপর ভিত্তি করে কিছু গণনা করা এবং রেকর্ড করা, যা পরবর্তীতে কৌশলগত যুক্তিতে ব্যবহার করা হয়। আমি সরাসরি উপরের কোডটিতে লিখেছি। জন্য_.reduceআমি এখানে একটি সহজ কথা বলতে চাই, যেটা হয়তো আমার সহপাঠীদের জন্য বিভ্রান্তিকর হতে পারে, যাদের প্রোগ্রামিংয়ের কোনো জ্ঞান নেই।_.reduceহ্যাঁUnderscore.jsএই লাইব্রেরির ফাংশন, FMZJS নীতি এই লাইব্রেরী সমর্থন করে, তাই এটি পুনরাবৃত্তিমূলক গণনা ব্যবহার করা সহজ।Underscore.js资料链接

এই শব্দটির অর্থ খুবই সহজ, যেমনঃ

function main () {
   var arr = [1, 2, 3, 4]
   var sum = _.reduce(arr, function(ret, ele){
       ret += ele
       
       return ret
   }, 0)

   Log("sum:", sum)    # sum 等于 10
}

এটা হচ্ছে সমষ্টি।[1, 2, 3, 4]আমরা এখানে যেসব সংখ্যা যোগ করেছি সেগুলোকে একসাথে যোগ করে।tradesঅ্যারেতে প্রতিটি লেনদেনের রেকর্ড ডেটা যার মধ্যে লেনদেনের সংখ্যা যোগ করা হয়। একটি সর্বশেষ লেনদেনের রেকর্ডের লেনদেনের পরিমাণ যোগ করা হয়।self.vol = 0.7 * self.vol + 0.3 * _.reduce(...)দয়া করে আমাকে অনুমতি দিন।...এখানে আপনি দেখতে পাচ্ছেন যে, এই কোডের পরিবর্তে,self.volএটিও একটি ওজনযুক্ত গড় হিসাব করা হয়; অর্থাৎ সর্বশেষতম অর্জিত লেনদেনের মোট লেনদেনের ওজন 30% এবং সর্বশেষের ওজনযুক্ত গণনার অর্জিত লেনদেনের ওজন 70%। এই অনুপাতটি কৌশল লেখকের দ্বারা সেট করা হয়েছে এবং সম্ভবত বাজারের নিয়মাবলী পর্যবেক্ষণের সাথে সম্পর্কিত। আপনি যদি আমাকে জিজ্ঞাসা করেন, যদি সাম্প্রতিক লেনদেনের তথ্য সংগ্রহ করে ইন্টারফেসটি আমাকে পুরানো ডেটা পুনরাবৃত্তি করে, তাহলে আমি কি ভুল তথ্য পেয়েছি এবং এটি ব্যবহারযোগ্য?

if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
    ...
}

এই রায়টি ⇒ লেনদেনের রেকর্ডে লেনদেনের আইডি-র উপর ভিত্তি করে রায় দেওয়া যেতে পারে, যা কেবলমাত্র যখন আইডিটি আগের রেকর্ডের আইডি-র চেয়ে বড় হয়, অথবা যদি এক্সচেঞ্জ ইন্টারফেসটি আইডি সরবরাহ না করে, তখনই সংযোজনটি শুরু হয়।trade.Id == 0লেনদেনের রেকর্ডের সময়সূচী ব্যবহার করে, এই সময়ে সিদ্ধান্ত নিন।self.lastTradeIdএই তথ্যটি একটি আইডি নয়, বরং একটি লেনদেনের রেকর্ডের টাইমলাইন।

দ্বিতীয় যোগ করা ফাংশনঃ

    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }

পরবর্তী দেখুনupdateOrderBookএই ফাংশনটি, ফাংশনের নামের আক্ষরিক অর্থ থেকে দেখা যায়, এই ফাংশনটির কাজ হল অর্ডারটি আপডেট করা।GetDepth()বর্তমান মার্কেট অর্ডার স্লিম ডেটা (একটি বিক্রি...একটি বিক্রি, একটি কিনতে...একটি কিনতে) এবং অর্ডার স্লিম ডেটা রেকর্ড করুনself.orderBookমধ্যম. পরবর্তী সিদ্ধান্ত যদি অর্ডার পাতলা ডেটা ক্রয়, বিক্রয় আদেশ 3 টিরও কম হয়, অবৈধ ফাংশন সরাসরি ফিরে আসে।

এরপরে, দুটি পরিসংখ্যান গণনা করা হয়েছিলঃ

• টিকিটের দাম গণনা করুন হিসাব করা টিকিটের দামও ওজনযুক্ত গড় গণনা ব্যবহার করা হয়, যখন অর্থ প্রদানের গণনা করা হয়, তখন একটি কেনার অধিকার 61.8% ((0.618), একটি বিক্রয়ের জন্য বাকি ওজন 38.2% ((0.382) । টিকিট বিক্রয় একক মূল্য গণনা করার সময় একইভাবে, একটি মূল্য অধিকার দিতে এবং বিক্রি করার জন্য একটি বড় মূল্য অধিকার। কেন 0.618, সম্ভবত লেখক তুলনামূলকভাবে স্বর্ণের বিভাজন অনুপাত পছন্দ করেন। শেষ যোগ করা এবং বিয়োগ করা এক বিন্দু বিন্দু মূল্য ((0.01) একটি সামান্য বিট সঞ্চালন কেন্দ্র থেকে deviating জন্য।

• আপডেট সময়সূচীতে অর্ডার হ্রাস প্রথম তিন স্তর ওভারওয়েড গড় মূল্য অর্ডার হ্রাসের জন্য প্রথম তিন শ্রেণীর ক্রয়, বিক্রয় আদেশের দামের জন্য ওজনযুক্ত গড় গণনা, প্রথম শ্রেণীর ওজন 0.7, দ্বিতীয় শ্রেণীর ওজন 0.2, তৃতীয় শ্রেণীর ওজন 0.1। কিছু সহকর্মী বলতে পারেঃ ওহ, না, কোডের মধ্যে কাঠের 0.7, 0.2, 0.1 আছে। আমরা গণনা শুরু করিঃ

  (买一 + 卖一) * 0.35 + (买二 + 卖二) * 0.1 + (买三 + 卖三) * 0.05
  ->
  (买一 + 卖一) / 2 * 2 * 0.35 + (买二 + 卖二) / 2 * 2 * 0.1 + (买三 + 卖三) / 2 * 2 * 0.05
  ->
  (买一 + 卖一) / 2 * 0.7 + (买二 + 卖二) / 2 * 0.2 + (买三 + 卖三) / 2 * 0.1
  ->
  第一档平均的价格 * 0.7 + 第二档平均的价格 * 0.2 + 第三档平均的价格 * 0.1
  

  এখানে দেখা যাচ্ছে যে, শেষ গণনা করা মূল্য আসলে বিপরীত বর্তমান বাজারে তিন শ্রেণীর মধ্যম স্থান মূল্য অবস্থান। তারপর এই হিসাবকৃত মূল্য ব্যবহার করে, আপডেট করুনself.pricesঅ্যারে, একটি প্রাচীনতম ডেটা ((( মাধ্যমে বের করেshift()ফাংশন), আপডেট একটি সর্বশেষ তথ্য (( মাধ্যমেpush()ফাংশন, Shift, Push ফাংশন হল JS ভাষার অ্যারে অবজেক্টের পদ্ধতি, যা JS তথ্য অনুসন্ধান করতে পারে) ।self.pricesএকটি ম্যাট্রিক্স একটি সময়সূচীযুক্ত ধারাবাহিকতার ডেটা স্ট্রিম।

কফ, মুখের পানি পান করুন, এখানে এসে বিশ্লেষণ করুন, পরের বার দেখা হবে।