ការវិភាគទិន្នន័យប្រេកង់ខ្ពស់ — ការដំណើរការទិន្នន័យផ្សារ Tick-Level

ការជួញដូរប្រេកង់ខ្ពស់នៅក្នុងគ្រីបតូដំណើរការនៅលើមាត្រដ្ឋានពេលវេលាមីលីវិនាទី/មីក្រវិនាទី។ ការដំណើរការរាប់លាននៃ ticks ក្នុងមួយថ្ងៃ ការគ្រប់គ្រងលំហូរទិន្នន័យដែលមានភាពខ្លាំង និងការដកសញ្ញា microstructure បំបែកអ្នកជួញដូរវិជ្ជាជីវៈពីអ្នកដទៃ។ មគ្គុទ្ទេសក៍នេះនឹងដើរតាមការគ្រប់គ្រងទិន្នន័យ Tick-Level និងការវិភាគពេលវេលាពិតដែលជាប្រភពថាមពលរបស់ Smart Money API ក្នុងវដ្តធ្វើឱ្យស្រស់រាល់ ៥ នាទី។

គន្លឹះសំខាន់៖ Whales មិនផ្លាស់ប្តូរទីផ្សារភ្លាមៗទេ។ ការជួញដូរប្លុករបស់ពួកគេបង្កើតហត្ថលេខាដែលអាចកត់សម្គាល់បាននៅក្នុងភាពមិនសម្បើមនៃការបញ្ជាទិញ ការរីករាយ bid-ask និងសមាមាត្របរិមាណ taker។ Smart Money API ចាប់យកហត្ថលេខាទាំងនេះជាពេលវេលាពិត។

ការប្រមូលនិងការផ្ទុកទិន្នន័យ Tick

ប្រភពទិន្នន័យ

សម្រាប់គ្រីបតូ ទិន្នន័យ tick មកពី៖

ការផ្ទុក Tick ដោយមានប្រសិទ្ធភាពជាមួយ Parquet

ផ្ទុកទិន្នន័យជួរឈរដែលបានបង្ហាប់សម្រាប់ការស្វែងរយៈពេលរហ័ស៖

Python — បំពង់ទិន្នន័យ Tick
import pandas as pd
import pyarrow.parquet as pq
# Real-time tick buffer (accumulate for 1h, then save)
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"
})
# Every hour, compress and save
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 Analysis

Level 2 Order Book Snapshots

ចាប់យកការបញ្ជាទិញពេញលេញរៀងរាល់ 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):
# Get best 10 bids and asks
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(ខ្លួនឯង):
best_bid = max(ខ្លួនឯង.bids.keys())
best_ask = min(ខ្លួនឯង.asks.keys())
ត្រឡប់ (best_ask - best_bid) / best_bid # ភាពខុសគ្នាគិតជាភាគរយ

សញ្ញាសំណង់អតិសុខុម

ស្រង់សញ្ញាអាចអនុវត្តបានពីរចនាសម្ព័ន្ធសៀវភៅពាក្យបញ្ជា៖

វាស់វែងសំណង់អតិសុខុមទីផ្សារ

តម្លៃមធ្យមដែលមានទម្ងន់បរិមាណ (VWAP)

ស្តង់ដារអនុវត្តល្អជាងតម្លៃបិទសាមញ្ញ៖

Python — ការគណនា VWAP
កំណត់ calculate_vwap(ticks):
# ticks: បញ្ជីនៃ (តម្លៃ, បរិមាណ) tuples
numerator = sum(price * volume សម្រាប់ price, volume នៅក្នុង ticks)
denominator = sum(volume សម្រាប់ _, volume នៅក្នុង ticks)
ត្រឡប់ numerator / denominator

សមាមាត្រ Taker ទិច/លក់

កំណត់អត្តសញ្ញាណថាតើផ្នែកណាដែលកំពុងធ្វើឱ្យកាន់តែអាជីវកម្ម៖

Python — ការវិភាគ Taker
កំណត់ get_taker_direction(tick):
# ប្រសិនបើតម្លៃជួញដូរ = bid នោះអ្នកលក់គឺអាជីវកម្ម (ការផ្គត់ផ្គង់)
# ប្រសិនបើតម្លៃជួញដូរ = ask នោះអ្នកទិញគឺអាជីវកម្ម (តម្រូវការ)
ប្រសិនបើ abs(tick.price - best_bid) < tick.price_step:
ត្រឡប់ "sell"
elif abs(tick.price - best_ask) < tick.price_step:
return "buy"
else:
return "mid" # នៅខាងក្នុងស្ប៉្រេដ អាចជាអាងងងឹត
buy_volume = sum(t.size for t in ticks if get_taker_direction(t) == "buy")
sell_volume = sum(t.size for t in ticks if get_taker_direction(t) == "sell")
return buy_volume / (buy_volume + sell_volume) # % ទិញ

ស្ថាបត្យកម្មបំពង់ទិន្នន័យពេលវេលាពិត

ការដំណើរការស្ទ្រីម WebSocket

តភ្ជាប់ទៅកាន់ Bybit/Binance/Hyperliquid WebSocket សម្រាប់ទិន្នន័យផ្ទាល់៖

Python — កម្មវិធីគ្រប់គ្រងស្ទ្រីមផ្ទាល់
import asyncio
import websockets
async def connect_bybit_ticks(symbol):
url = f"wss://stream.bybit.com/v5/public/spot"
async with websockets.connect(url) as ws:
# ជាវស្ទ្រីមពាណិជ្ជកម្ម
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async for message in ws:
data = json.loads(message)
for trade នៅក្នុង ទិន្នន័យ["ទិន្នន័យ"]:
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 — Redis stream processing
import redis
r = redis.Redis(host='localhost', port=6379)
# Producer: push ticks to 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
})
# Consumer group reads with lag tracking
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Add real-time signals to your analytics

Smart Money API aggregates tick data from 3 exchanges and 250+ whale wallets. Use our pre-computed microstructure signals to enhance your own real-time analysis.

Start Free Today →