ผมวิเคราะห์การเทรดของบอทบน Polymarket กว่า 10 ล้านรายการด้วย Claude: เผยวิธีที่บอททำกำไรได้มากกว่า 1,000 ดอลลาร์ต่อวัน

สำหรับเทรดเดอร์ทั่วไป ตลาด Polymarket ระยะสั้นดูเหมือนง่าย:

Bitcoin จะสูงขึ้นหรือต่ำลงในอีกห้านาทีข้างหน้า?

บอทเทรดมองเห็นปัญหาที่แตกต่างไปโดยสิ้นเชิง

มันกำลังติดตามราคาอ้างอิง เวลาที่เหลือจนหมดอายุ สภาพคล่องทั้งสองฝั่ง ตลาดที่เกี่ยวข้อง และสินค้าคงคลังสดของมันเอง — ทั้งหมดพร้อมกัน:

• สมัครสมาชิกช่อง Telegram ของฉันเพื่อรับข้อมูลเพิ่มเติม✍️🤫: https://t.me/+VDXq5wkZ2AIxMDBi

ลิงก์กระเป๋าเงิน: https://polymarket.com/@bonereaper?via=dan-kwpx

ในขณะที่มนุษย์ยังคงตัดสินใจว่าจะซื้อ Up หรือ Down บอทอาจทำสิ่งเหล่านี้ไปแล้ว:

**> รับสัญญาณราคาใหม่ > ประเมินราคาผลลัพธ์ใหม่ > เปรียบเทียบกับราคาสัญญา > ตรวจสอบตลาดใกล้เคียง > วางคำสั่ง limit หลายรายการ > ปรับเปลี่ยนสถานะทั้งหมด**

นั่นคือวิธีที่ระบบเหล่านี้บางระบบเปลี่ยนช่องว่างราคาเล็กน้อยให้เป็นกำไรมากกว่า $1,000 ต่อวัน

ฉันวิเคราะห์กิจกรรมของบอทมากกว่า 1,000 ตัว และการดำเนินการมากกว่า 10 ล้าน ครั้ง ในตลาดคริปโต Up/Down ระยะสั้นของ Polymarket ผ่าน Claude

ในตอนแรก การเทรดดูวุ่นวายอย่างสิ้นเชิง กระเป๋าเงินเดียวกันซื้อ Up ไม่กี่วินาทีต่อมาก็เพิ่ม Down ขายส่วนหนึ่งของสถานะแรก และจบตลาดด้วยการถือทั้งสองผลลัพธ์

แต่เมื่อคุณสร้างวงจรชีวิตการเทรดทั้งหมดขึ้นมาใหม่ เสียงรบกวนก็เริ่มมีเหตุผล โดยปกติแล้วจะมีระบบที่เฉพาะเจาะจงมากอยู่เบื้องหลัง

นี่คือวิธีการทำงานของเครื่องจักรทั้งหมด 👇

1. เหตุใดจึงใช้บอทเทรดบน Polymarket

ข้อได้เปรียบหลักของบอทไม่ใช่การคาดการณ์ Bitcoin ที่สมบูรณ์แบบ

ข้อได้เปรียบของมันมาจากความเร็ว ความสม่ำเสมอ และความสามารถในการประมวลผลข้อมูลมากกว่าที่มนุษย์จะติดตามได้ตามจริงในเวลาเดียวกัน:

ลิงก์กระเป๋าเงิน: https://polymarket.com/@0xb55fa1296e6ec55d0ce53d93b9237389f11764d4-1777575277609?via=dan-kwpx

สัญญาระยะสั้นไม่ได้ถูกกำหนดราคาโดยว่า Bitcoin กำลังเคลื่อนไหวขึ้นหรือลงเท่านั้น

อัลกอริทึมยังต้องคำนึงถึง:

**> ระยะห่างจากราคาเปิด > ความเร็วของการเคลื่อนไหวล่าสุด > เวลาที่เหลือ > ความผันผวนในปัจจุบัน > ความลึกของ order book > ราคาของ Up และ Down > พฤติกรรมในตลาดที่เกี่ยวข้อง > ฟีดที่แน่นอนที่ใช้สำหรับการตัดสิน**

ในตลาดห้านาที โอกาสที่แท้จริงอาจมีอยู่เพียงไม่กี่วินาที

มนุษย์อาจยังคงสลับไปมาระหว่างแผนภูมิ ในขณะที่อัลกอริทึมอื่นกำลังรับสภาพคล่องที่มีอยู่และแทนที่คำสั่งของมันแล้ว

บอทเทรดส่วนใหญ่สร้างขึ้นจากองค์ประกอบหลักห้าประการ:

1. เลเยอร์ข้อมูล - สตรีมราคาภายนอกและการอัปเดต order book
2. เอนจินสัญญาณ - ตรวจจับการเปลี่ยนแปลงที่อาจส่งผลต่อผลลัพธ์
3. โมเดลความน่าจะเป็น - คำนวณความน่าจะเป็นที่ยุติธรรมอย่างอิสระ
4. เอนจินการดำเนินการ - วาง ยกเลิก และปรับคำสั่ง
5. ผู้จัดการความเสี่ยง - ควบคุมขนาดสถานะและบล็อกการเทรดที่เกินขีดจำกัดที่กำหนดไว้ล่วงหน้า

สัญญาณหนึ่งที่บอทสามารถคำนวณได้โดยตรงจาก order book คือความไม่สมดุลระหว่างปริมาณผู้ซื้อและผู้ขาย:

1def orderbook_imbalance(bids, asks):
2    bid_volume = sum(size for price, size in bids)
3    ask_volume = sum(size for price, size in asks)
4
5    total_volume = bid_volume + ask_volume
6
7    if total_volume == 0:
8        return 0.0
9
10    return (
11        bid_volume - ask_volume
12    ) / total_volume
13
14bids = [
15    (0.48, 1_250),
16    (0.47, 920),
17    (0.46, 680)
18]
19
20asks = [
21    (0.49, 640),
22    (0.50, 510),
23    (0.51, 430)
24]
25
26imbalance = orderbook_imbalance(bids, asks)
27
28print(f"Order-book imbalance: {imbalance:.2%}")

ค่าบวก หมายถึงมีปริมาณผู้ซื้อมากกว่าในส่วนของ order book ที่วิเคราะห์ ค่าลบ หมายถึงปริมาณผู้ขายมากกว่า สัญญาณนี้เพียงอย่างเดียวไม่ได้พิสูจน์ว่าราคาจะเคลื่อนไหว

คำสั่งขนาดใหญ่สามารถถูกยกเลิกได้ และสภาพคล่องที่อยู่ไกลจากราคาที่ดีที่สุดอาจไม่ส่งผลต่อการดำเนินการ

แต่เมื่อรวมกับการเคลื่อนไหวของ Bitcoin เวลาที่เหลือ และฟีดราคาภายนอก มันก็กลายเป็นส่วนหนึ่งของสัญญาณที่แข็งแกร่งขึ้น

บอทไม่ได้มีประโยชน์เพราะมันเทรดทุกการเคลื่อนไหวของตลาดโดยอัตโนมัติ ระบบที่แข็งแกร่งจะได้รับความได้เปรียบโดยการปฏิเสธการตั้งค่าส่วนใหญ่ก่อนที่จะกลายเป็นสถานะ

2. หลังจากได้รับสัญญาณ บอทจะอัปเดตความน่าจะเป็นด้วย Bayes 🧮

สมมติว่า Up กำลังเทรดที่ 41¢

Bitcoin เร่งความเร็วขึ้นอย่างกะทันหัน ปริมาณเพิ่มขึ้น และ order book เริ่มแสดงแรงกดดันจากผู้ซื้อที่แข็งแกร่งขึ้น

มนุษย์อาจคิดว่า:

การเคลื่อนไหวนี้ดูแข็งแกร่ง

Up

อาจมีราคาต่ำเกินไป

อัลกอริทึมต้องการคำตอบที่แม่นยำกว่า:

สัญญาณนี้เปลี่ยนความน่าจะเป็นของ

Up

ไปเท่าไหร่กันแน่?

นี่คือจุดที่ ทฤษฎีบทของ Bayes เข้ามามีบทบาท

ลิงก์กระเป๋าเงิน: https://polymarket.com/@0xce25e214d5cfe4f459cf67f08df581885aae7fdc-1777575398144?via=dan-kwpx

Bayes ช่วยให้โมเดลเริ่มต้นด้วยความน่าจะเป็นที่มีอยู่และอัปเดตหลังจากได้รับหลักฐานใหม่

สูตรคือ:

P(Up | Signal) = P(Signal | Up) × P(Up) / [P(Signal | Up) × P(Up) + P(Signal | Down) × P(Down)]

โดยที่:

P(Up)

* คือความน่าจะเป็นก่อนได้รับสัญญาณใหม่ *

P(Signal | Up)

* คือความถี่ที่สัญญาณนี้ปรากฏก่อนผลลัพธ์ Up *

P(Signal | Down)

* คือความถี่ที่ปรากฏก่อนผลลัพธ์ Down *

P(Up | Signal)

คือความน่าจะเป็นที่อัปเดตแล้ว

สมมติว่า:

ความน่าจะเป็นเดิมของ

Up

* คือ 41% สัญญาณนี้ปรากฏใน 64% ของสถานการณ์ *

Up

* ในอดีต สัญญาณเดียวกันปรากฏใน 35% ของสถานการณ์ *

Down

ในอดีต

1def bayes_update(
2    prior_up,
3    signal_given_up,
4    signal_given_down
5):
6    numerator = signal_given_up * prior_up
7
8    denominator = (
9        numerator
10        + signal_given_down * (1 - prior_up)
11    )
12
13    return numerator / denominator
14
15prior = 0.41
16
17posterior = bayes_update(
18    prior_up=prior,
19    signal_given_up=0.64,
20    signal_given_down=0.35
21)
22
23print(f"Previous probability: {prior:.2%}")
24print(f"Updated probability: {posterior:.2%}")

ค่าประมาณที่อัปเดตคือประมาณ 56% หากสัญญายังคงเทรดที่ 41¢ บอทจะเห็นช่องว่างที่วัดได้:

*มูลค่ายุติธรรมภายใน - 56% ราคาตลาด - 41¢ ส่วนต่างทางทฤษฎี - 15 จุดเปอร์เซ็นต์*

สำหรับมนุษย์ สิ่งนี้อาจดูเหมือนเป็นไอเดียการเทรดที่แข็งแกร่ง สำหรับ บอท มันคือความแตกต่างเฉพาะระหว่างมูลค่ายุติธรรมและราคาตลาดปัจจุบัน

อย่างไรก็ตาม Bayes ไม่ใช่ทางลัดในการทำนาย

หากโมเดลให้น้ำหนักกับสัญญาณที่อ่อนแอมากเกินไป หรือนับข้อมูลเดียวกันหลายครั้ง ผลลัพธ์จะบิดเบือนอย่างสม่ำเสมอ

การเคลื่อนไหวของราคา ปริมาณที่เพิ่มขึ้น และความไม่สมดุลของ order book อาจดูเหมือนการยืนยันสามครั้งที่แยกจากกัน เมื่อจริงๆ แล้วมันเป็นผลกระทบสามประการจากเหตุการณ์เดียวกัน

โมเดลที่แข็งแกร่งจำเป็นต้องคำนึงถึงการทับซ้อนนั้น

3. สัญญาที่ตั้งราคาผิดไม่ได้หมายถึงการเทรดที่ทำกำไรได้โดยอัตโนมัติ

แม้ว่าโมเดลจะประเมินค่า Up ไว้ที่ 56% การซื้อมันที่ 41¢ ก็ไม่ได้สร้างกำไรโดยอัตโนมัติ

การดำเนินการจริงรวมถึง:

*> ค่าธรรมเนียม taker > ส่วนต่าง bid-ask > slippage > การเติมบางส่วน > การเสื่อมสภาพของราคา > ความไม่แน่นอนของโมเดล*

ดังนั้นบอทจึงคำนวณ ส่วนต่างสุทธิ - ความได้เปรียบที่เหลืออยู่หลังจากดำเนินการสถานะจริง

1def calculate_net_edge(
2    model_probability,
3    execution_price,
4    fee,
5    slippage,
6    safety_buffer
7):
8    gross_edge = (
9        model_probability - execution_price
10    )
11
12    net_edge = (
13        gross_edge
14        - fee
15        - slippage
16        - safety_buffer
17    )
18
19    return gross_edge, net_edge
20
21gross, net = calculate_net_edge(
22    model_probability=0.56,
23    execution_price=0.47,
24    fee=0.017,
25    slippage=0.005,
26    safety_buffer=0.010
27)
28
29print(f"Gross edge: {gross:.2%}")
30print(f"Net edge: {net:.2%}")

ช่องว่างเก้าจุดเดิมลดลงเหลือประมาณหกจุดหลังจากหักต้นทุน

หากสภาพคล่องมีจำกัด บอทอาจเติมสถานะได้เพียงส่วนเล็กน้อยที่ 47¢ ขนาดที่เหลืออาจต้องซื้อในราคาที่สูงกว่า

ส่วนต่างอาจหายไปก่อนที่สถานะทั้งหมดจะถูกสร้างขึ้น ตรรกะเดียวกันนี้ใช้กับ การเก็งกำไรแบบไบนารี

หากสามารถซื้อ Up และ Down ในปริมาณเท่ากันได้ในราคาต่ำกว่า $1 หลังจากหักต้นทุนทั้งหมดแล้ว ฝั่งใดฝั่งหนึ่งจะจ่าย $1 ในที่สุด

แต่ระบบต้องใช้ราคาดำเนินการแบบถ่วงน้ำหนักตามปริมาณจริง ไม่ใช่แค่ราคาที่น่าสนใจที่สุดที่เห็นที่ด้านบนของ order book

นี่คือจุดที่การทดสอบย้อนหลังที่สะอาดและการดำเนินการสดมักให้ผลลัพธ์ที่แตกต่างกันมาก มนุษย์สังเกตเห็นราคาที่ผิดปกติ บอท ต้องพิสูจน์ว่ามีมูลค่าเพียงพอเหลืออยู่หลังจากรวมต้นทุนตลาดแล้ว

4. ส่วนต่างที่ดีที่สุดมักอยู่ระหว่างตลาดที่เกี่ยวข้อง 🕸

สัญญาระยะสั้นไม่ได้เคลื่อนไหวอย่างโดดเดี่ยว

การเคลื่อนไหวของ Bitcoin หนึ่งครั้งสามารถส่งผลกระทบต่อทั้งหมดต่อไปนี้:

> หน้าต่าง

BTC

* 5 นาทีปัจจุบัน > หน้าต่างห้านาทีถัดไป > *

BTC

* 15 นาที > *

BTC

* 1 ชั่วโมง > ตลาด *

ETH

และ

SOL

ที่เกี่ยวข้อง

แต่ตลาดเหล่านี้ไม่ได้อัปเดตด้วยความเร็วเท่ากันเสมอไป

แต่ละสัญญามี order book สภาพคล่อง ระดับเปิด และผู้เข้าร่วมของตัวเอง

ตัวอย่างเช่น:

>

BTC

* 5 นาทีอาจปรับราคาทันที > *

BTC

* 15 นาทีอาจตอบสนองน้อยกว่าที่คาด > หน้าต่างใกล้เคียงอาจคงความไม่สมดุลของ order book ก่อนหน้าไว้ > สัญญาหนึ่งอาจมีราคาแพง > อีกสัญญาหนึ่งอาจยังคงเทรดตามสมมติฐานที่ล้าสมัย*

ลิงก์กระเป๋าเงิน: https://polymarket.com/@flippingsharks?via=dan-kwpx

บอทจะวัดว่าช่องว่างระหว่างตลาดที่เกี่ยวข้องได้เคลื่อนออกไปนอกช่วงปกติหรือไม่

เครื่องมือง่ายๆ อย่างหนึ่งคือ z-score:

Z = (ส่วนต่างปัจจุบัน − ส่วนต่างเฉลี่ย) / ส่วนเบี่ยงเบนมาตรฐาน

1def spread_zscore(
2    current_spread,
3    average_spread,
4    spread_deviation
5):
6    return (
7        current_spread - average_spread
8    ) / spread_deviation
9
10z = spread_zscore(
11    current_spread=0.112,
12    average_spread=0.036,
13    spread_deviation=0.025
14)
15
16print(f"Spread z-score: {z:.2f}")

ค่าที่อ่านได้สูงกว่า 3 หมายถึงช่องว่างปัจจุบันอยู่ไกลเกินกว่าช่วงที่โมเดลมักจะสังเกตเห็น

นั่นไม่ได้สร้างการเทรดโดยอัตโนมัติ ตลาดหนึ่งอาจล้าหลังอย่างแท้จริง หรือตลาดที่เคลื่อนไหวก่อนอาจรวมข้อมูลที่สัญญาใกล้เคียงยังไม่ได้ประมวลผลแล้ว

บอท ยังไม่สามารถเปรียบเทียบ BTC 5 นาที และ BTC 15 นาที โดยดูแค่ราคา Up ของพวกมันเท่านั้น

พวกมันมีระดับเปิดที่แตกต่างกันและมีเวลาที่เหลือแตกต่างกัน

ระบบที่จริงจังจะเปรียบเทียบว่าแต่ละสัญญาเคลื่อนห่างจากโมเดลมูลค่ายุติธรรมของตัวเองไปเท่าใด

มนุษย์ดูตลาดเดียว บอทดูเครือข่ายของความน่าจะเป็นที่เชื่อมโยงกันและระบุส่วนที่เคลื่อนห่างจากส่วนอื่นชั่วคราว

5. ห้าวิธีที่บอทเปลี่ยนส่วนต่างให้เป็นสถานะ 🔄

เมื่อสัญญาณได้รับการยืนยันแล้ว ความน่าจะเป็นได้รับการอัปเดต และส่วนต่างสุทธิยังคงเป็นบวก ขั้นตอนที่น่าสนใจที่สุดก็เริ่มต้นขึ้น

บอทต้องตัดสินใจวิธีสร้างและจัดการสถานะ

หลังจากจัดกลุ่มการดำเนินการแต่ละรายการเป็นวงจรการเทรดที่สมบูรณ์ โมเดลที่เกิดขึ้นซ้ำห้าแบบก็ปรากฏขึ้น

1️⃣ การหมุนเวียนสถานะแบบไดนามิก

ระบบนี้จะอัปเดตมุมมองอย่างต่อเนื่องและอาจเปลี่ยนทิศทางหลายครั้งภายในสัญญาเดียวกัน สมมติว่าโมเดลพิจารณาว่า Up มีราคาต่ำเกินไปในช่วงเริ่มต้นของตลาดห้านาที

มันเริ่มสะสม Up ผ่านคำสั่ง limit

จากนั้นการตั้งค่าก็เปลี่ยนไป:

Bitcoin

* สูญเสียโมเมนตัม ราคาเคลื่อนกลับไปสู่ระดับเปิด ผู้ซื้อหายไปจาก order book ความน่าจะเป็นของ *

Up

ของโมเดลลดลง

บอท ไม่จำเป็นต้องถือสถานะเดิมจนกว่าจะถึงเวลาตัดสิน มันสามารถขาย Up บางส่วน ยกเลิกคำสั่งที่เหลือ และเริ่มสะสม Down

หากตลาดเปลี่ยนแปลงอีกครั้ง สถานะก็สามารถสร้างขึ้นใหม่ได้อีกครั้ง เป้าหมายไม่ใช่การระบุผลลัพธ์สุดท้ายอย่างสมบูรณ์แบบในครั้งแรก

เป้าหมายคือการเปิดรับฝั่งใดก็ตามที่มีราคาต่ำกว่าค่าประมาณที่อัปเดตของโมเดลในปัจจุบันมากกว่า

จุดแข็งของแนวทางนี้คือบอทสามารถละทิ้งมุมมองที่ล้าสมัยได้ทันที

จุดอ่อนหลักคือการกลับทิศทางที่ผิดพลาดซ้ำแล้วซ้ำเล่า

ในช่วงที่มีสัญญาณรบกวน ระบบอาจ:

ซื้อ

Up

* หลังจากเคลื่อนไหวสูงขึ้น ลดมันลงหลังจากมีการดึงกลับ สลับไปเป็น *

Down

* ลด *

Down

หลังจากการเคลื่อนไหวสูงขึ้นครั้งถัดไป

ต้นทุนการดำเนินการและการเปลี่ยนแปลงสถานะซ้ำๆ สามารถค่อยๆ ลบความได้เปรียบดั้งเดิมออกไป

ดังนั้นบอทแบบหมุนเวียนควรเปลี่ยนทิศทางก็ต่อเมื่อสัญญาณใหม่แข็งแกร่งพอที่จะครอบคลุมต้นทุนของการออก การสร้างสถานะใหม่ และความเป็นไปได้ที่จะผิดอีกครั้ง:

ลิงก์กระเป๋าเงิน: https://polymarket.com/@trinity42?via=dan-kwpx

2️⃣ การเก็งกำไรชั่วคราว (Temporal Arbitrage)

การเก็งกำไร แบบดั้งเดิมเกิดขึ้นเมื่อสามารถซื้อ Up และ Down พร้อมกันได้ในราคาต่ำกว่า $1

การเก็งกำไรชั่วคราวจะสร้างทั้งสองฝั่งในเวลาที่ต่างกัน ลองนึกภาพ Bitcoin เคลื่อนไหวสูงขึ้นอย่างรวดเร็วหลังจากตลาดเปิดไม่นาน

Down ลดลงเหลือ 26¢ และบอทค่อยๆ สะสม 750 สัญญาในราคาเฉลี่ย 27.4¢ สองนาทีต่อมา Bitcoin คืนการเคลื่อนไหวส่วนใหญ่และเทรดใกล้ระดับเปิด

ตอนนี้ Up กลายเป็นราคาถูกลง และบอทซื้อ Up จำนวน 750 สัญญาในราคาเฉลี่ย 49.8¢

โครงสร้างสุดท้ายคือ:

*750 Down ที่ 27.4¢ 750 Up ที่ 49.8¢ ต้นทุนรวมต่อคู่ที่สมบูรณ์ - 77.2¢*

ไม่ว่าผลลัพธ์สุดท้ายจะเป็นอย่างไร หนึ่งสัญญาในทุกคู่จะจ่าย $1 ซึ่งสร้างอัตรากำไรขั้นต้น 22.8¢ ต่อคู่ ก่อนหักค่าธรรมเนียมและต้นทุนการดำเนินการ รายละเอียดสำคัญคือ Down ที่ 27.4¢ และ Up ที่ 49.8¢ ไม่เคยมีพร้อมกันในเวลาเดียวกัน

บอทสร้างการเก็งกำไรจากสถานะตลาดที่แตกต่างกันสองสถานะ อย่างไรก็ตาม การซื้อครั้งแรกยังคงมีความเสี่ยงด้านทิศทาง

หาก Bitcoin ยังคงเคลื่อนไหวสูงขึ้น บอทอาจไม่ได้รับราคา Up ที่น่าสนใจพอที่จะทำให้คู่สมบูรณ์

มันจะเหลือสัญญา Down 750 สัญญาที่มูลค่าลดลงเรื่อยๆ

ดังนั้นระบบจึงติดตาม:

*ปริมาณที่ถือในแต่ละฝั่ง ต้นทุนเฉลี่ยของทั้งสองผลลัพธ์ ต้นทุนของสินค้าคงคลังที่ได้รับการป้องกันแล้ว ขนาดของสถานะทิศทางที่ไม่ได้จับคู่ เวลาสูงสุดที่อนุญาตให้รอฝั่งที่สอง*

บอทบางตัวสร้างโครงสร้างเป็นบล็อกเล็กๆ

พวกมันอาจซื้อ Down 100 รอจนกว่าจะเพิ่ม Up 100 ได้ ทำให้คู่ที่ป้องกันคู่แรกสมบูรณ์ จากนั้นจึงเพิ่มขนาดต่อไป

วิธีนี้ลดผลตอบแทนสูงสุดที่อาจได้รับ แต่ยังจำกัดความเสี่ยงของการถูกทิ้งไว้กับสถานะฝั่งเดียวขนาดใหญ่

การเก็งกำไรชั่วคราวทำงานได้ดีที่สุดในตลาดที่มีการเคลื่อนไหวที่มีความหมายหลายครั้งในทั้งสองทิศทาง

การเคลื่อนไหวทิศทางเดียวยาวนานเป็นสภาพแวดล้อมที่ยากที่สุด:

ลิงก์กระเป๋าเงิน: https://polymarket.com/@garvy?via=dan-kwpx

3️⃣ บอททำตลาดสินค้าคงคลัง (Inventory Market-Making Bot)

ระบบนี้ไม่ได้จัดการสถานะเดียว มันจัดการสินค้าคงคลังทั้งหมดของสัญญา

มันอาจเทรด:

*BTC, ETH และ SOL ตลาด 5 นาที, 15 นาที, 1 ชั่วโมง และ 4 ชั่วโมง ทั้ง Up และ Down ในหลายหน้าต่าง*

บอทซื้อและขายในปริมาณเล็กน้อยในขณะที่ติดตามต้นทุนรวมของสินค้าคงคลังอย่างต่อเนื่อง สมมติว่ามันสะสมทั้งสองฝั่งของสัญญาหนึ่ง ใกล้หมดอายุ Down กลายเป็นตัวเต็งที่ชัดเจนและเคลื่อนไปที่ 98¢

แทนที่จะรอการตัดสินเฉยๆ บอทอาจ:

*ขายส่วนหนึ่งของสินค้าคงคลัง Down ที่มีราคาแพง ปลดปล่อยเงินทุนก่อนการชำระบัญชี เก็บส่วนที่เหลือของสถานะหลักไว้ ซื้อ Up จำนวนเล็กน้อยที่ 2¢ ย้ายเงินทุนที่มีอยู่ไปยังตลาดอื่น*

การซื้อฝั่งราคาต่ำอาจดูผิดปกติในตอนแรก

แต่สถานะเล็กๆ ที่ 1–2¢ สามารถทำหน้าที่เป็นประกันราคาถูกต่อการเคลื่อนไหวครั้งสุดท้ายอย่างกะทันหัน หากไม่มีอะไรเปลี่ยนแปลง ต้นทุนก็มีจำกัด หาก Bitcoin ข้ามระดับเปิดอย่างไม่คาดคิด สถานะ Up เล็กๆ สามารถชดเชยส่วนหนึ่งของการขาดทุนที่อื่นได้

บอทสินค้าคงคลังยังสามารถใช้ประโยชน์จากความแตกต่างระหว่างตลาดที่เกี่ยวข้อง

สัญญาหนึ่งอาจเสนอราคาเข้าที่ดี อีกสัญญาหนึ่งอาจให้สภาพคล่องที่ลึกกว่าสำหรับการออก สัญญาที่สามอาจเสนอฝั่งตรงข้ามในราคาที่ต่ำผิดปกติ

ความท้าทายหลักคือต้นทุนเฉลี่ยของสินค้าคงคลังทั้งหมด

หากต้นทุน Up เฉลี่ยคือ 56¢ และต้นทุน Down เฉลี่ยคือ 49¢ หนึ่งคู่ที่ป้องกันมีราคา $1.05

การตัดสินจ่ายเพียง $1

เพื่อกู้คืนส่วนต่างห้าเซ็นต์นั้น ระบบต้องการกำไรเพิ่มเติมจากการขายสินค้าคงคลังที่มีราคาแพง การรักษาความไม่สมดุลของทิศทางที่ควบคุมได้ การได้รับ rebate ผู้สร้าง หรือการย้ายเงินทุนอย่างมีประสิทธิภาพมากขึ้นข้ามตลาด:

ลิงก์กระเป๋าเงิน: https://polymarket.com/@polkadot-frog?via=dan-kwpx

4️⃣ บอททิศทางที่มีการป้องกันความเสี่ยง (Hedged Directional Bot)

โครงสร้างนี้อยู่ระหว่างการเก็งกำไรบริสุทธิ์และสถานะทิศทางเต็มรูปแบบ

สมมติว่าบอทถือ:

*280 Up 257 Down*

257 Up และ 257 Down แรกสร้างฐานที่ได้รับการป้องกัน ไม่ว่าผลลัพธ์สุดท้ายจะเป็นอย่างไร ฝั่งหนึ่งของบล็อกนี้จะจ่าย $257 สัญญา Up ที่เหลือ 23 สัญญาสร้างความโน้มเอียงในทิศทาง

หาก Up เป็นผลลัพธ์สุดท้าย สัญญาเพิ่มเติมเหล่านั้นจะเพิ่มการจ่ายเงิน หาก Down เป็นผลลัพธ์สุดท้าย สถานะตรงข้ามจะครอบคลุมการเปิดรับส่วนใหญ่

ระบบกำลังบอกอย่างมีประสิทธิภาพว่า:

โมเดลของฉันตอนนี้ชอบ Up แต่ฉันไม่ต้องการให้สถานะทั้งหมดขึ้นอยู่กับผลลัพธ์เดียว

ขนาดของความไม่สมดุลสามารถเปลี่ยนแปลงได้ตลอดตลาด เมื่อความมั่นใจเพิ่มขึ้น บอทจะเพิ่ม Up มากขึ้น เมื่อสัญญาณอ่อนลง บอทจะลด Up หรือซื้อ Down เพิ่มเติม

การถือทั้งสองฝั่งไม่ได้ทำให้โครงสร้างมีประสิทธิภาพโดยอัตโนมัติ

หากคู่ที่ป้องกันถูกสร้างขึ้นเหนือ $1 พวกมันจะสร้างอัตรากำไรติดลบที่รับประกัน

สมมติว่าต้นทุนคู่เฉลี่ยคือ $1.04 สัญญา Up พิเศษ 23 สัญญาต้องกู้คืนการขาดทุนบนฐานที่ป้องกันก่อน พร้อมกับค่าธรรมเนียมและ slippage

หลังจากนั้นเท่านั้น สถานะทั้งหมดจึงจะทำกำไรได้

ในบางกรณี การป้องกันความเสี่ยงที่มีราคาแพงนั้นมีประสิทธิภาพน้อยกว่าการรักษาสถานะทิศทางที่เล็กกว่า:

ลิงก์กระเป๋าเงิน: https://polymarket.com/@uuddlrlr?via=dan-kwpx

5️⃣ บอทจับการตัดสินช่วงท้าย (Late-Resolution Capture Bot)

โมเดลสุดท้ายมุ่งเน้นไปที่ช่วงปิดของตลาดเกือบทั้งหมด

เมื่อผลลัพธ์หนึ่งใกล้จะถูกกำหนด ฝั่งสุดท้ายที่น่าจะเป็นไปได้อาจยังคงเทรดที่ 98–99¢ บอทจะซื้อปริมาณที่เหลือที่มีอยู่และรอการจ่ายเงิน $1

ตัวอย่างเช่น:

*เข้า ที่ 98.6¢ จ่ายเงินที่ $1 กำไรขั้นต้น - 1.4¢ ต่อสัญญา*

ผลตอบแทนจากการดำเนินการแต่ละครั้งมีน้อย ดังนั้นระบบจึงสแกนตลาดจำนวนมากและใช้ปริมาณมาก

กลยุทธ์อาจดูคาดเดาได้สูง แต่โปรไฟล์ผลตอบแทนของมันไม่สม่ำเสมอมาก

หาก 99 การดำเนินการสร้างหนึ่งเซ็นต์ต่อครั้ง และสถานะ 99¢ หนึ่งครั้งตัดสินผิดพลาด กำไรก่อนหน้านี้สามารถหายไปได้

การดำเนินการที่ผิดพลาดหนึ่งครั้งนั้นอาจเกิดจาก:

*การเคลื่อนไหวครั้งสุดท้ายที่รุนแรง ความแตกต่างระหว่างฟีดราคา ระดับเปิดที่ไม่ถูกต้อง การอัปเดตการตัดสินที่ล่าช้า ความเข้าใจผิดเกี่ยวกับกฎของตลาด คำสั่งที่ยังคงใช้งานนานเกินไป*

ดังนั้นระบบการตัดสินช่วงท้ายจึงต้องการมากกว่าความเร็ว

มันต้องรู้อย่างแน่ชัดว่าฟีดใดเป็นตัวกำหนดผลลัพธ์ และค่าปัจจุบันอยู่ห่างจากขอบเขตสัญญาเท่าใด

โครงสร้างสถานะสุดท้ายสามารถวิเคราะห์ได้ด้วยโปรแกรม

1def inspect_position(
2    up_quantity,
3    down_quantity,
4    up_average_price,
5    down_average_price
6):
7    protected_pairs = min(
8        up_quantity,
9        down_quantity
10    )
11
12    directional_up = max(
13        up_quantity - down_quantity,
14        0
15    )
16
17    directional_down = max(
18        down_quantity - up_quantity,
19        0
20    )
21
22    pair_cost = (
23        up_average_price
24        + down_average_price
25    )
26
27    return {
28        "protected_pairs": protected_pairs,
29        "extra_up": directional_up,
30        "extra_down": directional_down,
31        "average_pair_cost": pair_cost,
32        "pair_margin": 1 - pair_cost
33    }
34
35position = inspect_position(
36    up_quantity=280,
37    down_quantity=257,
38    up_average_price=0.51,
39    down_average_price=0.46
40)
41
42print(position)

แต่ภาพรวมสุดท้ายยังคงไม่เปิดเผยกลยุทธ์ที่สมบูรณ์

เพื่อทำความเข้าใจระบบ คุณจำเป็นต้องรู้ว่าสถานะถูกสร้างขึ้นมาอย่างไร ส่วนใดถูกขาย และต้นทุนเฉลี่ยเปลี่ยนแปลงไปตามเวลาอย่างไร

6. การค้นหาราคาที่ผิดไม่เพียงพอ — บอทยังต้องจับมันให้ได้ 🎯

สมมติว่าบอทพบโอกาสในการซื้อ Up และ Down รวมกันที่ 94¢ มันส่งคำสั่งทั้งสอง Up เต็มจำนวน

ก่อนที่ Down จะเต็ม ตลาดเคลื่อนไหว สภาพคล่องที่มีอยู่หายไป และฝั่งที่สองมีราคาแพงขึ้น

การเก็งกำไรไม่มีอยู่อีกต่อไป

บอท ตอนนี้กำลังถือสถานะ Up ทิศทางที่เปิดอยู่

นี่คือความเสี่ยงด้านสินค้าคงคลัง

ระบบที่แข็งแกร่งไม่สามารถเพียงแค่ระบุราคาที่ผิดปกติ มันต้องจัดการกระบวนการดำเนินการทั้งหมด

มันต้องตัดสินใจ:

*จะรอฝั่งที่สองนานแค่ไหน เมื่อใดควรปรับคำสั่ง limit ยอมรับความไม่สมดุลได้มากแค่ไหน เมื่อใดควรเป็น maker และเมื่อใดควรดำเนินการเป็น taker จะลดฝั่งแรกหลังจากส่วนต่างหายไปหรือไม่*

วิธีหนึ่งในการจัดการกับสิ่งนี้คือผ่านตรรกะที่ได้รับแรงบันดาลใจจากโมเดล Avellaneda–Stoikov

แนวคิดหลักนั้นง่าย: ราคาเสนอที่ยอมรับได้ควรเปลี่ยนแปลงตามสินค้าคงคลังที่ถืออยู่แล้ว

สูตรอย่างง่ายคือ:

ราคาสำรอง = ราคายุติธรรม − สินค้าคงคลัง × ความเสี่ยง × ความผันผวน² × เวลา

1def reservation_price(
2    fair_price,
3    inventory,
4    risk_aversion,
5    volatility,
6    time_remaining
7):
8    inventory_adjustment = (
9        inventory
10        * risk_aversion
11        * volatility ** 2
12        * time_remaining
13    )
14
15    return fair_price - inventory_adjustment
16
17quote = reservation_price(
18    fair_price=0.57,
19    inventory=0.40,
20    risk_aversion=0.80,
21    volatility=0.18,
22    time_remaining=0.25
23)
24
25print(f"Inventory-adjusted quote: {quote:.3f}")

หากบอทถือ Up มากเกินไปแล้ว มันควรจะเต็มใจน้อยลงที่จะซื้อ Up เพิ่มเติม

ในเวลาเดียวกัน มันสามารถก้าวร้าวมากขึ้นเมื่อได้มาซึ่ง Down เพื่อลดความไม่สมดุล

ประเภทคำสั่งก็มีความสำคัญเช่นกัน:

GTC

* ยังคงใช้งานอยู่จนกว่าจะถูกเติมหรือยกเลิก *

GTD

* หมดอายุตามเวลาที่กำหนด *

FOK

* เต็มทั้งหมดหรือถูกยกเลิก *

FAK

* เติมปริมาณที่มีอยู่และยกเลิกส่วนที่เหลือ *

Post-only

รับประกันว่าคำสั่งจะเพิ่มสภาพคล่อง

ในตลาดห้านาที คุณภาพของการดำเนินการอาจสำคัญกว่าการคาดการณ์เบื้องต้น

โมเดลสามารถประมาณมูลค่ายุติธรรมได้อย่างถูกต้อง แต่ก็ยังขาดทุนได้หากสร้างสถานะช้าเกินไปหรือที่ราคาเฉลี่ยที่ไม่มีประสิทธิภาพ

7. ชั้นสุดท้ายคือการกำหนดขนาดสถานะและการปกป้องเงินทุน 🛡

ความได้เปรียบที่แข็งแกร่งไม่ได้หมายความว่าควรจัดสรรเงินทุนทั้งหมดที่มีให้กับตลาดเดียว

มีความเป็นไปได้เสมอที่:

*โมเดลประเมินสัญญาณสูงเกินไป ฝั่งตรงข้ามไม่เข้ามาเติมสภาพคล่อง สภาพคล่องหายไป ราคาเฉลี่ยที่ได้แย่กว่าที่คาดไว้ สถานะที่เกี่ยวข้องกันหลายรายการสูญเสียมูลค่าพร้อมกัน*

จุดเริ่มต้นทั่วไปสำหรับการกำหนดขนาดสถานะคือเกณฑ์ Kelly

สูตรคือ:

f = (b × p − q) ÷ b

\*

โดยที่:

p

* คือความน่าจะเป็นของความสำเร็จ *

q = 1 − p

* คือความน่าจะเป็นของความล้มเหลว *

b

* คืออัตราการจ่ายสุทธิเมื่อเทียบกับจำนวนเงินที่เสี่ยง *

f

\ คือเศษส่วนของ Kelly แบบเต็ม*

ในทางปฏิบัติ หลายระบบใช้เพียงเศษเสี้ยวของผลลัพธ์

1def fractional_kelly(
2    win_probability,
3    entry_price,
4    fraction=0.25
5):
6    lose_probability = 1 - win_probability
7
8    net_odds = (
9        1 - entry_price
10    ) / entry_price
11
12    full_kelly = (
13        net_odds * win_probability
14        - lose_probability
15    ) / net_odds
16
17    return max(
18        full_kelly * fraction,
19        0
20    )
21
22allocation = fractional_kelly(
23    win_probability=0.61,
24    entry_price=0.50,
25    fraction=0.25
26)
27
28print(f"Capital allocation: {allocation:.2%}")

Kelly แบบเศษส่วนช่วยลดโอกาสที่การประมาณค่าโมเดลที่ไม่แม่นยำเพียงครั้งเดียว หรือการดำเนินการที่แย่ จะสร้างความเสียหายอย่างรุนแรงต่อกลยุทธ์

จากนั้นระบบจะใช้ขีดจำกัดที่เข้มงวด:

*ขนาดสูงสุดต่อสถานะ การเปิดรับสูงสุดต่อสินทรัพย์ ขีดจำกัดสินค้าคงคลังที่ไม่มีการป้องกัน ขีดจำกัดการขาดทุนรายวัน การปิดระบบฉุกเฉินเมื่อข้อมูลไม่น่าเชื่อถือ*

ความสัมพันธ์ก็มีความสำคัญเช่นกัน

BTC 5 นาที, BTC 15 นาที, ETH 5 นาที และ SOL 5 นาที อาจดูเหมือนเป็นตลาดที่แยกจากกัน แต่ในช่วงที่คริปโตเคลื่อนไหวในวงกว้าง สิ่งเหล่านี้อาจสูญเสียมูลค่าพร้อมกันได้

บทบาทของผู้จัดการความเสี่ยงไม่ใช่การเพิ่มขนาดของทุกโอกาสที่น่าสนใจให้สูงสุด

บทบาทของมันคือการทำให้แน่ใจว่าไม่มีสถานการณ์ใดสถานการณ์หนึ่งที่สามารถลบล้างความสามารถของระบบในการดำเนินงานต่อไปได้

8. โครงสร้างบอทที่สมบูรณ์มีหน้าตาอย่างไร ⚙️

บอท Polymarket สมัยใหม่ไม่ใช่สคริปต์ Python ตัวเดียวที่เปรียบเทียบ Binance กับราคา Up

โดยปกติแล้วมันทำงานในหลายชั้น

ชั้นที่ 1 - ข้อมูลตลาด

ราคาภายนอก, ฟีดผลลัพธ์อย่างเป็นทางการ, สมุดคำสั่งซื้อขายสด, การซื้อขายล่าสุด และสถานะของคำสั่งของบอทเอง

ชั้นที่ 2 - สัญญาณ

การเคลื่อนไหวของราคา, ปริมาณ, ความผันผวน, ความไม่สมดุลของสมุดคำสั่ง และความแตกต่างระหว่างตลาดที่เกี่ยวข้องกัน

ชั้นที่ 3 - ความน่าจะเป็น

โมเดลจะอัปเดตความน่าจะเป็นที่ยุติธรรมเมื่อใดก็ตามที่มีข้อมูลใหม่ที่มีความหมายเข้ามา

ชั้นที่ 4 - ตรรกะของสถานะ

ระบบจะเลือกระหว่างการหมุนเวียน, การเก็งกำไรตามช่วงเวลา, การจัดการสินค้าคงคลัง, การป้องกันความเสี่ยงตามทิศทาง หรือการดำเนินการเมื่อใกล้ถึงเวลาสิ้นสุด

ชั้นที่ 5 - การดำเนินการและความเสี่ยง

คำสั่งซื้อขายถูกวาง, ยกเลิก และปรับเปลี่ยน ในขณะที่สินค้าคงคลังและขนาดสถานะยังคงอยู่ภายในขีดจำกัดที่กำหนดไว้ล่วงหน้า

ชั้นที่ 6 - การวิจัย

ใช้ Claude เพื่อวิเคราะห์ประวัติการซื้อขาย, ระบุโครงสร้างที่เกิดขึ้นซ้ำ, เขียน backtest และศึกษาเกี่ยวกับรอบการซื้อขายที่ไม่ประสบความสำเร็จ

ลูประดับสูงอาจมีลักษณะเช่นนี้

1async def run_bot():
2    while True:
3        state = await receive_market_update()
4
5        signal = build_signal(state)
6        probability = update_probability_model(
7            state,
8            signal
9        )
10
11        edge = scan_for_edge(
12            state,
13            probability
14        )
15
16        if not edge["tradable"]:
17            continue
18
19        position_plan = choose_position_model(
20            state,
21            edge
22        )
23
24        orders = build_execution_plan(
25            state,
26            position_plan
27        )
28
29        if risk_manager_approves(
30            orders,
31            state
32        ):
33            await send_orders(orders)

Claude สามารถช่วยระบุว่าโครงสร้างใดเกิดขึ้นซ้ำๆ ในการดำเนินการนับล้านครั้งในประวัติศาสตร์

แต่ลูปการซื้อขายที่มีความหน่วงต่ำนั้นควรจะคงที่: รับข้อมูล, ใช้กฎ, ตรวจสอบขีดจำกัด และส่งคำสั่งซื้อขาย

สรุป: บอทที่ทำกำไรได้ทำมากกว่าแค่เลือกขึ้นหรือลง

ตลาดระยะสั้นดูเหมือนจะเป็นสัญญาทางทิศทางที่เรียบง่าย

ระบบที่ทำกำไรได้จะดำเนินการตามลำดับที่ยาวนานกว่ามาก:

*รับสัญญาณใหม่ แปลงเป็นความน่าจะเป็น ตรวจสอบความได้เปรียบสุทธิ เปรียบเทียบตลาดที่เกี่ยวข้อง เลือกโครงสร้างสถานะ จัดการการดำเนินการ จำกัดความเสี่ยง*

บอท บางตัวสลับระหว่างขึ้นและลงหลายครั้งภายในกรอบเวลาเดียวกัน บางตัวสะสมทั้งสองฝั่งในเวลาที่ต่างกัน บางตัวจัดการสินค้าคงคลังขนาดใหญ่ในหลายกรอบเวลา ส่วนบางตัวคงฐานที่ได้รับการป้องกันไว้โดยมีความโน้มเอียงตามทิศทางเพียงเล็กน้อย

อีกกลุ่มหนึ่งมุ่งเน้นไปที่การจับส่วนต่างราคาที่เหลืออยู่ก่อนถึงเวลาสิ้นสุด

แต่สูตรหลักมักจะคล้ายกัน:

*ข้อมูลที่เชื่อถือได้ การประมาณความน่าจะเป็นอย่างอิสระ ความได้เปรียบหลังจากหักต้นทุน โครงสร้างสถานะที่ถูกต้อง การดำเนินการที่แม่นยำ ความเสี่ยงที่ถูกควบคุม*

บอท เหล่านี้ไม่รู้ว่า Bitcoin จะอยู่ที่ไหนในอีกห้านาทีข้างหน้า

พวกมันเพียงแค่คำนวณได้เร็วกว่าว่าผลลัพธ์ที่เป็นไปได้แต่ละอย่างควรมีมูลค่าเท่าใดในตอนนี้

ขอบคุณที่อ่านบทความของฉัน ฉันยินดีรับฟังคำติชม!

ติดตามฉันบน X✌️: https://x.com/Dan1ro0

เข้าร่วม Telegram ของฉันเพื่อรับข้อมูลเพิ่มเติม✍️: https://t.me/+VDXq5wkZ2AIxMDBi