ການວິເຄາະຂໍ້ມູນຄວາມຖີ່ສູງ — ການປະມວນຜົນຂໍ້ມູນຕະຫຼາດໃນລະດັບ Tick

ການຊື້ຂາຍຄວາມຖີ່ສູງໃນຄຣິບໂຕເຮັດວຽກໃນເວລາພິມລີວິນາທີ/ໄມໂຄວິນາທີ. ການປະມວນຜົນຂໍ້ມູນ Tick ຫຼາຍລ້ານຕໍ່ມື້, ຈັດການກະແສຂໍ້ມູນທີ່ເກີດຂຶ້ນຢ່າງກະທັນຫັນ, ແລະ ການສະກັດສັນຍານໂຄງສ້າງຈຸລະພາກແຍກຜູ້ຊື້ຂາຍມືອາຊີບອອກຈາກຄົນອື່ນ. ຄູ່ມືນີ້ຈະສະແດງການຈັດການຂໍ້ມູນໃນລະດັບ Tick ແລະ ການວິເຄາະແບບ Real-time ທີ່ເປັນພື້ນຖານຂອງການປັບປຸງທຸກໆ 5 ນາທີຂອງ Smart Money API.

ຈຸດສຳຄັນ: ປາກົດການຊື້ຂາຍຂອງວານ (Whales) ບໍ່ໄດ້ເຮັດໃຫ້ຕະຫຼາດເຄື່ອນໄຫວທັນທີ. ການຊື້ຂາຍຂະຫນາດໃຫຍ່ຂອງພວກເຂົາຈະສ້າງລາຍເຊັນທີ່ສາມາດຕິດຕາມໄດ້ໃນຄວາມບໍ່ສົມດຸນຂອງ Order Book, ຊ່ອງຫວ່າງລະຫວ່າງລາຄາຊື້-ຂາຍ, ແລະ ອັດຕາສ່ວນປະລິມານການຊື້ຂາຍ. Smart Money API ຈັບລາຍເຊັນເຫຼົ່ານີ້ໃນແບບ Real-time.

ການລວບລວມ ແລະ ການເກັບຮັກສາຂໍ້ມູນ Tick

ແຫຼ່ງຂໍ້ມູນ

ສຳລັບຄຣິບໂຕ, ຂໍ້ມູນ Tick ມາຈາກ:

ການເກັບຮັກສາຂໍ້ມູນ Tick ຢ່າງມີປະສິດທິພາບດ້ວຍ Parquet

ເກັບຂໍ້ມູນແບບຄໍລຳນີ້ເພື່ອການສອບຖາມໄວ:

Python — ຂະບວນການຂໍ້ມູນ Tick
import pandas as pd
import pyarrow.parquet as pq
# ບັນຈຸ Tick ແບບ Real-time (ສະສົມເປັນເວລາ 1 ຊົ່ວໂມງ, ຈຶ່ງບັນທຶກ)
tick_buffer = []
def on_tick(exchange, symbol, price, size, side, timestamp):
tick_buffer.append({
"timestamp": timestamp,
"exchange": exchange,
"symbol": symbol,
"price": price,
"size": size,
"side": side # "buy" or "sell"
})
# ທຸກໆ 1 ຊົ່ວໂມງ, ບີບອັດ ແລະ ບັນທຶກ
if len(tick_buffer) > 1_000_000:
df = pd.DataFrame(tick_buffer)
pq.write_table(
pa.Table.from_pandas(df),
f"ticks/{symbol}_{timestamp:%Y%m%d_%H}.parquet",
compression="snappy"
)
tick_buffer = []

ການວິເຄາະ Order Book

ພາບຖ່າຍ Order Book ລະດັບ 2

ຈັບຂໍ້ມູນ Order Book ເຕັມທຸກໆ 100-500ms:

Python — ການປະມວນຜົນ Order Book
class OrderBook:
def __init__(self):
self.bids = {} # price -> size
self.asks = {} # price -> size
def update(self, side, price, size):
if side == "bid":
if size == 0: del self.bids[price]
else: self.bids[price] = size
else:
if size == 0: del self.asks[price]
else: self.asks[price] = size
def get_imbalance(self, depth=10):
# ເອົາລາຄາຊື້ ແລະ ຂາຍທີ່ດີທີ່ສຸດ 10 ລາຍການ
top_bids = sorted(self.bids.items(), reverse=True)[:depth]
top_asks = sorted(self.asks.items())[:depth]
bid_volume = sum(size for _, size in top_bids)
ask_volume = sum(size for _, size in top_asks)
# ຄວາມບໍ່ສົມດຸນ: >1 = ຕະຫຼາດຂຶ້ນ (ມີແຮງຊື້ຫຼາຍ)
ກັບຄືນ bid_volume / ask_volume ຖ້າ ask_volume > 0 ອື່ນ 1.0
ກຳນົດ get_spread(self):
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
ກັບຄືນ (best_ask - best_bid) / best_bid # ຄວາມກວ້າງຂອງ spread ເປັນເປີເຊັນ

ສັນຍານຈາກໂຄງສ້າງຕະຫຼາດ

ສະແດງສັນຍານທີ່ສາມາດດຳເນີນການໄດ້ຈາກໂຄງສ້າງສັບຊື້-ຂາຍ:

ເຄື່ອງມືວັດແທກໂຄງສ້າງຕະຫຼາດ

ລາຄາສະເລ່ຍຖ່າຍນ້ຳໜັກປະລິມານ (VWAP)

ຕົວຊີ້ວັດການປະຕິບັດທີ່ດີກວ່າລາຄາປິດງ່າຍໆ:

Python — ການຄຳນວນ VWAP
ກຳນົດ calculate_vwap(ticks):
# ticks: ລາຍຊື່ຂອງຄູ່ລາຄາ, ປະລິມານ
numerator = sum(price * volume ສຳລັບ price, volume ໃນ ticks)
denominator = sum(volume ສຳລັບ _, volume ໃນ ticks)
ກັບຄືນ numerator / denominator

ອັດຕາສ່ວນ Taker Buy/Sell

ຈຳແນກວ່າດ້ານໃດກຳລັງມີຄວາມກ້າວຫນ້າ:

Python — ການວິເຄາະ Taker
ກຳນົດ get_taker_direction(tick):
# ຖ້າລາຄາຊື້ = bid, ຜູ້ຂາຍແມ່ນຜູ້ກ້າວຫນ້າ (ການສະໜອງ)
# ຖ້າລາຄາຊື້ = ask, ຜູ້ຊື້ແມ່ນຜູ້ກ້າວຫນ້າ (ຄວາມຕ້ອງການ)
ຖ້າ abs(tick.price - best_bid) < tick.price_step:
ກັບຄືນ "sell"
ອີກຢ່າງຫນຶ່ງ ຖ້າ abs(tick.price - best_ask) < tick.price_step:
ກັບຄືນ "buy"
ອື່ນ:
ກັບຄືນ "mid" # ພາຍໃນ spread, ອາດຈະເປັນ dark pool
buy_volume = sum(t.size ສຳລັບ t ໃນ ticks ຖ້າ get_taker_direction(t) == "buy")
sell_volume = sum(t.size ສຳລັບ t ໃນ ticks ຖ້າ get_taker_direction(t) == "sell")
ກັບຄືນ buy_volume / (buy_volume + sell_volume) # % ຊື້

ໂຄງສ້າງທໍ່ສົ່ງຂໍ້ມູນແບບ Real-Time

ການປະມວນຜົນ WebSocket Stream

ເຊື່ອມຕໍ່ກັບ Bybit/Binance/Hyperliquid WebSocket ເພື່ອຂໍ້ມູນຕະຫຼາດຕອນ:

Python — ຕົວຈັດການ live stream
ນຳເຂົ້າ asyncio
ນຳເຂົ້າ websockets
async ກຳນົດ connect_bybit_ticks(symbol):
url = f"wss://stream.bybit.com/v5/public/spot"
async ພ້ອມກັບ websockets.connect(url) ເປັນ ws:
# ສະໝັກຮັບການຊື້ຂາຍ
ລໍຖ້າ ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async ສຳລັບ message ໃນ ws:
data = json.loads(message)
ສຳລັບ trade ໃນ data["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

ການປະມວນຜົນແບບແຈກຢາຍດ້ວຍ Redis Streams

ຈັດການຫຼາຍລ້ານ ticks ຕໍ່ມື້ດ້ວຍຄິວຂໍ້ຄວາມ:

Python — ການປະມວນຜົນ stream Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Producer: ສົ່ງ ticks ໄປຫາ stream
def publish_tick(exchange, symbol, tick):
stream_key = f"ticks:{exchange}:{symbol}"
r.xadd(stream_key, {
"price": tick.price,
"size": tick.size,
"side": tick.side,
"ts": tick.timestamp
})
# ກຸ່ມຜູ້ບໍລິໂພກອ່ານພ້ອມການຕິດຕາມ lag
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

ເພີ່ມສັນຍານແບບ real-time ໃຫ້ກັບການວິເຄາະຂອງທ່ານ

Smart Money API ລວບລວມຂໍ້ມູນ tick ຈາກ 3 ຕະຫຼາດຊື້ຂາຍ ແລະ 250+ ກະເປົາເງິນ whale. ນຳໃຊ້ສັນຍານ microstructure ທີ່ຄຳນວນໄວ້ລ່ວງໜ້າຂອງພວກເຮົາເພື່ອປັບປຸງການວິເຄາະ real-time ຂອງທ່ານເອງ.

ເລີ່ມຟຣີມື້ນີ້ →