หาจุดซื้อขายในโลกของ Bot Trade เขาทำกันยังไง ?

สามารถดู video ของหัวข้อนี้ก่อนได้ ดู video

บทความต้นฉบับ (ย้ายมาจาก medium) https://blog.mikelopster.dev/c22fb267c2b

เรื่องนี้สืบเรื่องจากที่ผมไปนั่งฟังเรื่องการทำ AI มา แล้วก็มีคนมาสอบถามผมประมาณว่า ทำ bot trade เนี้ยจริงๆเขาทำกันยังไง ผมก็คิดว่าก็ไม่น่ายากนะ เราก็ Train AI เรียนรู้สภาวะตลาด แล้วจากนั้นเราก็ให้มันช่วยหาจุดซื้อขายให้เราได้… จากนั้นผมก็อึ้งไปแปบนึง แล้วก็นึกขึ้นได้ว่า

เออว่ะ แล้วไอ Bot ที่ว่าเนี่ย มันรู้ได้ยังไงว่าควรเลือกจุดซื้อ จุดขายตอนไหน

เพราะเวลาอย่างเรา Trade เนี่ย เราก็มักจะตอบกันอย่างง่ายๆว่าเราควรซื้อเมื่อราคาถูก แล้วควรขายเมื่อแพง ประเด็นคือ ถูกแพงเนี้ยมันวัดกันยังไงบ้าง ?

หลายๆคนผมเชื่อว่าน่าจะรู้จักเทคนิคอย่าง Technical Analysis ของวงการเทรดหุ้นกัน ไอเดียนี้เขาก็จะมีสัญญาณซื้อ / ขาย เช่นเดียวกัน โดยอ้างอิงตามข้อมูลสถิติและนำข้อมูลนั้นมา “ตีความใหม่” เพื่อให้สามารถใช้ทำเป็นสัญญาณซื้อขายได้ บ้างก็จะมี ตัดเส้น EMA แบบนั้น, ถ้า RSA เริ่มสูง แปลว่าตลาดเริ่ม oversold = ต้องขายเพราะมันเริ่มมีคนเทขายกันเยอะ อะไรแบบนี้

ผมก็เลยคิดว่า เราต้องใช้ไอเดียเดียวกันคือ เราต้อง “ตีความ” ออกมาว่า

1. สัญญาณซื้อ Bot เราควรซื้อเมื่อใด ?
2. สัญญาณขาย Bot เราควรขายเมื่อใด ?

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

1. Technical Analysis = ใช้เทคนิคคอลเนี่ยแหละทำ bot ซะเลย (ใช้ข้อมูลทางสถิติมาเป็นตัวชี้วัดแล้วคิดสัญญาณขึ้นมาเอง)
2. Find “Fair price” for put / call action (Black-Scholes model) = ใช้ทฤษฎีในการหา “ราคาทางทฤษฎี” ออกมาแล้วใช้วิเคราะห์ทางราคาเพื่อหาสัญญาณซื้อขาย
3. Deep learning with LSTM = ใช้ RNN ช่วย “ทำนายรราคา” ในการหาสัญญาณซื้อขายร่วมกัน
4. Deep Q Reinforcement learning = สร้าง AI ขึ้นมาที่เรียนรู้กฎการ trade ของตัวเองได้ ให้มันต่อสู้กับตลาดอันโหดร้าย แล้วให้มันคิดเอาเองว่ามันควรเทรดยังไง

จริงๆมันอาจจะมีเทคนิคมากกว่าใน 4 ข้อนี้ก็ได้ แต่ที่ผมแยกออกมาเป็น 4 อันนี้เพราะผมอยากเล่นไอเดียกับ Bot ที่เป็นข้อมูลใส “Time series” เท่านั้น (เอาแค่ข้อมูลราคาซื้อขายบนกราฟ โดยจะไม่เอาข้อมูลภายนอกมาเกี่ยวข้องเลย) เลยรู้สึกว่ามีประมาณ 4 วิธีนี้แหละ ที่ไอเดียในการคิดแตกต่างกันชัดเจน จริงๆมันก็มีแนว Machine learning อย่าง Linear Regression หรือ การใช้ Technical Analysis ที่มันว้าวซ่ากว่านี้ แต่ผมรู้สึกว่า ท้ายที่สุดแก่นก็ยังคงมาตกภายใน 4 ข้อนี้อยู่ดี ก็เลยตัดสินใจหยิบมาแค่ 4 วิธีนี้พอ รวมถึงผมเองก็พยายามหยิบไอเดียที่ simple ที่สุดไว้ เผื่อเป็นไอเดียสำหรับคนที่สนใจอยากจะลองทำ bot trade ของตัวเองขึ้นมาด้วยเช่นกัน

ย้ำหนึ่งอย่างก่อนไปต่อ

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

สำนักที่ 1 — Technical Analysis

Technical Analysis คือวิธีการเทรดโดยใช้ข้อมูลทางสถิติมาเป็นตัวช่วยในการหาจุดเข้าซื้อและจุดขาย ซึ่งในเว็บไซต์เทรดอย่าง Tradingview จะเรียกสิ่งนี้กันว่า Indicator หรือเป็นดัชนีเพิ่มเติมที่ช่วยให้ข้อมูลในการ Trade มีมากขึ้น

จริงๆ Indicator มันก็มีหลายประเภทและหลายศาสตร์มาก แต่เนื่องจากผมจะเล่นกับเพียงราคาใน Time series เท่านั้น ผมเลยจะหยิบ Indicator แค่ 2 ประเภทนี้ (และเป็น indicator ที่ผมคุ้นเคย) มาเล่นเท่านั้นคือ

1. Indicator แบบ Trend Following เช่น EMA / SMA / MACD
2. Indicator แบบ Momentum เช่น RSA / Stochastic Oscillator

โดยผมจะใช้สัญญาณของ 2 Indicator นี้มาใช้ร่วมกันเพื่อหาสัญญาณซื้อขายนั่นเอง (เดี๋ยวผมจะลง detail เพิ่มเติมตอนทำจริงด้านล่างอีกที)

เรื่อง Indicator ใน Technical Analysis มีบทความที่เขียนถึงเยอะมาก ถ้าใครสนใจ เอา keyword search อ่านเพิ่มเติมกันเองนะครับ

สำนักที่ 2 — Find “Fair price” for put / call action (Black-Scholes model)

Ref: http://www.espenhaug.com/black_scholes.html

ในปี 1973 นักเศรษฐศาสตร์ 2 คน Fischer Black และ Myron Scholes (ร่วมกับ Robert) ได้พยายามสร้าง Model การคำนวนราคาของ option ออกมา ใน Model ชื่อว่า Black Scholes model ซึ่งจริงๆสมการนี้ถูกสร้างขึ้นมาเพื่อหาราคาเหมาะสมสำหรับการ call (สัญญาณซื้อ) และ put (สัญญาณขาย) ตามทฤษฎีทางเศรษฐศาสตร์ (โดยใช้เหล่าตัวแปรที่เราต้องใส่ในสมการด้านบนนั่นแหละ) อย่างภาพด้านบนคือสมการของ Black Scholes model ซึ่งจะประกอบไปด้วย 2 ฝั่งคือ ฝั่ง Call และ ฝั่ง Put เพื่อหาราคาสำหรับสัญญาณ โดยเราจะแทนตัวแปรแต่ละตัวเข้าไปตามนี้

• S (stock price) = ราคาปัจจุบัน ณ ขณะนั้น
• X (strike price) = ราคาที่สนใจจะทดลอง (ผมเข้าใจว่างี้นะ จากที่อ่านมาหลายๆที่ ถ้าผมเข้าใจผิดบอกผมได้เลย เพราะผมอ่านแล้วก็งงเหมือนกัน 😭)
• r (Risk-free interest rate) = อัตราดอกเบี้ย โดยปราศจากความเสี่ยงต่อปี
• σ (Volatility) = ค่าความผันผวน เพื่อบอกว่าราคาผันผวนมากน้อยแค่ไหน (ตอนทำจริง เดี๋ยวเราจะบอกว่าเราจะคำนวนยังไง)
• N(x) = ค่าการกระจายความน่าจะเป็นแบบปกติมาตรฐาน

โดยการคำนวนนี้จะไม่คำนึงถึงการปันผลและค่าธรรมเนียมทางธุรกรรม รวมถึงไม่คำนึงถึงกฎการเทรดด้วยว่าตลาดสามารถ short ได้หรือไม่ด้วย

ผมเรียกไอเดียในสำนักนี้ว่า การหา “Fair price” หรือราคาที่สามารถ take action ได้เมื่อถึงราคาที่กำหนด (บางที่จะเรียกว่า ราคาตามทฤษฎีหรือ Theorical price) คือ ราคานี้เกิดขึ้นจากสมการการคำนวนเท่านั้น ไม่ได้เกิดจากการใช้ข้อมูลในอดีต หรือ ข้อมูลอื่นๆประกอบเลย แค่เอาตัวแปรบางอย่างใส่เข้าไปในสมการและวิเคราะห์เป็นราคาออกมา ซึ่งปกติ ทฤษฎีพวกนี้จะถูกใช้สำหรับการ “ประเมินความเสี่ยง” ว่าราคาตอนนี้มันเกินกว่าราคาที่เราประเมินไว้แล้วหรือไม่

แน่นอนครับ ไอเดียนี้ไม่ได้โดยสร้างมาสำหรับการทำ day trade เลย เป็นไอเดียที่โดยสร้างมาเพื่อใช้สำหรับการประเมินแค่นั้น แต่สำหรับการทดลองนี้ เราจะลองหยิบมาดู โดยพยายาม tune ตัวแปรบางอย่างเพื่อหาราคาที่สามารถ take action ออกมาได้ ซึ่งอาจจะผิดตามหลักการการใช้ของทฤษฎีนี้ก็ได้ แต่รู้สึกว่า คู่ควรแต่การลองอยู่ เพราะมันอาจจะเจอ Pattern อะไรบางอย่างจากการใช้สมการนี้ก็ได้

จริงๆไอเดียแนวนี้ ไม่ได้มีแค่ Black Scholes model นะ เพราะอย่าง model นี้มันก็เป็น style ของ European-style options ซึ่งไอเดียมันก็พูดไว้ว่า มันเหมาะสมกับการทดลองในช่วงก่อนเวลา expiration จะหมดลง (สมการมันจะมีใส่อยู่ว่าการคำนวนนี้หมดอายุเมื่อไหร่) ซึ่งมันก็มี American-style อีกที่มีการใช้ expiration ที่แตกต่างกัน รวมถึงมันก็มี model ที่ไอเดียคล้ายๆกันอย่าง Binomial options pricing model, Monte Carlo อยู่ แต่เลือกใช้ตัวนี้เพราะเข้าใจง่ายสุดและสมการตรงไปตรงมาที่สุดและ

สำนักที่ 3 — Deep learning with LSTM

อะไรๆก็ต้อง AI และแน่นอนว่า AI เองก็สามารถที่จะ “ทำนายตัวเลข” จาก Time series ออกมาได้เช่นกัน ปัจจุบันศาสตร์ AI อย่าง Deep learning ที่สามารถแกะ information บางอย่างที่แม้เราจะอธิบายไม่ได้ว่า information ที่อยู่ตรงกลางมันคืออะไร (ไม่รู้ว่าควรใช้อะไรในการให้ข้อมูลเพิ่มเติมสำหรับการ Train) ก็สามารถที่จะได้ผลลัพธ์ที่ต้องการออกมาได้

Ref: https://rdbi.co.th/2020/01/data-scientist-7/

Deep learning คือ ไอเดียที่เป็น subset ของ Machine Learning ที่จะใช้สิ่งที่เรียกว่า “Neural network” มาเป็นตัวหลักในการทำ Feature extraction (หา feature ที่อยู่ภายในข้อมูล) และ Classification (บอกว่าสิ่งที่ได้มานี้คืออะไร) ซึ่งตัว NN (ตัวย่อของ Neural network) เองก็มีหลายประเภทที่จะใช้แตกต่างกันสำหรับข้อมูลในแต่ละประเภท เช่น ถ้าเป็นข้อมูลภาพก็จะใช้ Convolutional neural network (ย่อว่า CNN) เพื่อบอกว่า ของในภาพนั้นคืออะไร

สำหรับเคสของ Time series เราจะเรียกข้อมูลประเภทนี้ว่า “ข้อมูลที่ต่อเนื่อง” กัน โดยข้อมูลที่ผ่านไปก่อนหน้ามีผลต่อการ Train ข้อมูลตัวปัจจุบันอยู่ (เช่น ข้อมูลการ Trade เมื่อ 3 วันก่อน อาจจะมีผลกับการ Predict ราคาในวันปัจจุบัน) ไม่ว่าจะเป็นเสียง / วิดีโอ หรือแม้แต่การแปลภาษา เองก็ถือเป็นข้อมูลประเภทนี้เหมือนกัน ซึ่งปกติเราจะใช้สิ่งที่เรียกว่า Recurrent neural network (ย่อว่า RNN)ในการ Train data

Ref: https://rdbi.co.th/2020/01/data-scientist-7/

ทีนี้ ปัญหาของ RNN คือ มันดันเอาข้อมูลเป็น Train โดยที่ไม่ filter อะไรออกเลย เช่น ถ้าสมมุติข้อมูลก่อนหน้า 1 step มีข้อมูลที่เป็น noise (ข้อมูลที่เราไม่อยากให้ร่วมวิเคราะห์ด้วย) อยู่ มันจะกลายเป็นข้อมูลทั้งเส้นทางจะโดน train ให้เป็นข้อมูลอีกแบบไปได้ รวมถึงเมื่อข้อมูลเริ่มมีขนาดยาวมาก RNN เองอาจจะเผลอทำ information หายไประหว่างทางได้

LSTM เลยเกิดมาเพื่อแก้ปัญหานี้ของ RNN แบบปกติ คือการเพิ่ม hidden layer เพื่อเป็น memory ให้กับ RNN เพิ่มเข้ามารวมถึงเพิ่ม function สำหรับการ filter ข้อมูลเพื่อให้สามารถ “ลืม” สิ่งที่ไม่จำเป็นสำหรับข้อมูลออกไปได้ เพื่อให้ยังสามารถเก็บข้อมูลมาได้ครบทั้งเส้นทางได้

เราจะใช้ ไอเดีย นี้ในการ Train ข้อมูลเพื่อทำการ “ทำนายราคา” ของราคา option เพื่อไปสร้างสัญญาณซื้อขายต่อไปกัน

สำนักที่ 4 — Deep Q Reinforcement learning

อีกประเภทหนึ่งของ Machine learning ที่ถือว่าฮิตไม่ต่างกัน (โดยเฉพาะยุคสมัยนี้ที่ chatgpt กำลังโด่งดัง หรืออย่างยุคของ AlphaGo เองก็ถูกพูดถึงเช่นกัน) คือ Reinforcement learning

Reinforcement learning (ขอย่อว่า RL) คือ การสร้างกฎบางอย่างให้กับ Bot (ในที่นี้คือ Agent) แล้วให้ Agent เล่นตาม policy (กฎที่กำหนดเอาไว้ให้ Agent ตัวนั้นเล่น) โดยอิงจากของ 2 อย่างคือ state ปัจจุบันคืออะไร และ Action ที่จะทำคืออะไร เพื่อหา reward (มูลค่าปัจจุบัน) ไปคำนวนร่วมกับทุก action แล้วเอามูลค่าสูงสุดของ action นั้นออกมาเพื่อทำให้เกิดเป็น state ต่อไปได้

ถ้าอ่านแล้วยังงง ขอยกตัวอย่างให้เห็นภาพมากขึ้นเช่นเกมด้านล่าง เกมตารางง่ายๆที่พยายามพาหุ่นยนต์ลงไปยังตำแหน่ง End โดย

• action ที่สามารถทำได้คือ up, down, left, right
• ทุกก่อนการเดิน หุ่นยนต์จะสำรวจก่อนว่า action ต่อไป และ state ต่อไป อันไหนมีมูลค่าสูงสุด ถ้าแบ่งออกจากเคสนี้คือ เดินขึ้นไป+ช่องด้านบน, เดินลงไป+ช่องด้านล่าง, เดินไปทางขวา+ช่องด้านขวา, เดินไปทางซ้าย+ช่องด้านซ้าย
• ใน 4 เคสนั้น อันไหนมีมูลค่าสูงสุด = จะเป็น action ที่หุ่นยนต์เลือกเดินไป reward วัดจากอัตราการทำให้เป้าหมายนั้นสำเร็จ ทุก action เราจะเอา reward มา update ว่า หลังจากการใช้ action นี้ที่ state นี้ มีมูลค่าเป็นเท่าไหร่ ถ้าใกล้เคียงกับเป้าหมายก็ให้ reward เป็นบวก ถ้าไม่ใกล้เลยหรือทำให้หุ่นยนต์ตาย (เช่น เดินไปด้านขวาแล้วเจอระเบิด) ก็ให้ reward เป็นลบ เพื่อให้การนำ หุ่นยนต์ตัวนี้มาทดสอบรอบหน้า จะทำให้หุ่นยนต์สามารถเดินได้ดีขึ้นได้

Ref: https://www.freecodecamp.org/news/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc/

ซึ่งวิธีการง่ายๆที่ชาว RL ส่วนนึงนิยมใช้กันสำหรับการเก็บข้อมูล action-state คือวิธีของ Q-Learning มันคือ RL แบบ model free นั่นคือการไม่ต้องมีการ fix policy เอาไว้ว่าต้องมีอะไรบ้าง แค่เก็บ state-action คู่กันไว้ในตารางที่ชื่อ Q Table ไว้ก็พอ ตามสมการและตัวอย่างตารางตามด้านล่างนี้

Ref: https://www.analyticsvidhya.com/blog/2019/04/introduction-deep-q-learning-python/

ไอเดียของ Q Table คือ เราจะสร้างตาราง Q table ขึ้นมาเก็บเอาไว้ให้หมดว่า ถ้า state เป็น แบบนี้, action เป็นแบบนี้ เราจะให้มูลค่ากับมัน (value หรือก็คือ reward) อยู่เท่าไหร่ เพื่อตามหา value สูงสุดในการออก action ออกมา เช่น ถ้าเป็นหุ่นยนต์ด้านบน state คือทุกช่องบนกระดาน และ action คือ up, down, right, left เราก็เอา state มาคูณกับจำนวน action และกลายเป็นจำนวนแถวของตารางนี้ขึ้นมาได้

ทีนี้ จุดอ่อนของ RL แนวนี้คือ Q Table จำเป็นต้องเก็บ state และ action ทั้งหมดเอาไว้ ซึ่งถ้า Bot ที่ไม่ได้มีความ complex มาก Q Learning ก็อาจจะเพียงพอ แต่พอ senario ที่มีความ complex มาก เช่น เคสที่เราจะทำกับกราฟราคาหุ้น ลองนึกถึงว่า ราคาก่อนหน้าวันปัจจุบัน มีผลต่อการออก action ในตอนปัจจุบันทั้งหมด นึกถึง action กับ state ที่เป็นไปได้ แค่คิดก็ปวดหัวและครับว่าควรกำหนดมันยังไงบ้าง

มันก็เลยมีสิ่งหนึ่งที่ช่วยมาเติมเต็มความสามารถของ Q Learning นั่นก็คือ Deep Q Learning คือการเปลี่ยน Q Table จากเดิมที่เก็บเป็นตาราง ไปเก็บใหม่ในรูปแบบของ Neuron network แทน

Ref: https://www.novatec-gmbh.de/en/blog/deep-q-networks/

เราจะใช้ไอเดียของ Neural network มาแทน Policy function และ table ที่อยู่ด้านบน ออกมาเป็น Neural network ที่เราจะทำการเก็บเพียงค่า weight ใน Neural network เอาไว้แทน

เดี๋ยวเราจะมาลองใช้ Deep Q RL ในการทำเรื่องนี้กันในการสร้าง DNN policy ที่สามารถ Trade ออกมาได้

เราจะมาลอง Train กันและ

อย่างแรกสุด ผมต้องทำให้ bot ทั้ง 4 ตัวพร้อมลงสนามก่อน สำนักที่ 1 (Technical Analysis), 2 (Fair price) จะไม่มีการ Train เกี่ยวข้องเนื่องจากใช้เพียงสมการคณิตศาสตร์ในการคำนวนเท่านั้น ส่วนสำนักที่ 3 (LSTM) กับ 4 (Deep Q RL) ผมจะ setting ไว้แบบนี้

• ผมจะเตรียม datatest ของ bitcoin (ซึ่งผมหยิบมาจาก kaggle) ในนั้นจะมีข้อมูลของปี 2020 และ 2021 อยู่ https://www.kaggle.com/datasets/prasoonkottarathil/btcinusd
• ผมจะใช้ข้อมูลของปี 2020 เป็นตัวตั้งในการ Train ทั้ง 2 AI ในสำนักที่ 3 (LSTM) และ 4 (Deep Q RL) และให้ทั้งคู่ไปทำการทดสอบ model ตัวเองผ่านการ Trade ข้อมูลปี 2021 แทน (เพื่อกันการ overfitting ของการใช้ข้อมูล)
• ข้อมูลที่เราจะใช้คำนวนทั้งหมดจะเป็น “ราคาปิด (close)” ของ ตลาด ณ วันนั้นๆ แบบ daily เนื่องจากสมเหตุสมผลที่จะนำไปใช้จริงกว่า เพราะถ้าเราลองเอาสิ่งนี้ไปใช้จริงแบบ realtime เราจะพยายามยึดตามราคาปัจจุบัน (ซึ่งก็คือราคาปิดขณะใช้งาน) เพื่อสร้าง Strategy อยู่แล้ว

ก่อนจะเริ่ม train ผมจะทำการ import dataset เข้ามาใส่ dataframe โดยใช้ pandas ไว้ และทำการแยก dataframe ของปี 2020 (สำหรับ Train) และปี 2021 (สำหรับการทดสอบ) ออกมา

# ดึง dataset เข้ามา
import pandas as pd
file_path = '/path_to_file/datasets/BTC-Daily.csv'
df = pd.read_csv(file_path)

# แปลง dataset เป็น format date และ filter date 2020 และ 2021 ออกจากกัน
df['c_date'] = pd.to_datetime(df['date'])
df_2020 = df[df['c_date'].dt.year == 2020]
df_2021 = df[df['c_date'].dt.year == 2021]

และนี่คือหน้าตา dataset โดยประมาณซึ่งเราจะสนใจเพียงแค่ 2 field เท่านั้นคือ

• date = วัน/เวลา ของข้อมูล (เนื่องจากข้อมูลเป็น daily วันเวลาก็จะเป็นเที่ยงคืนของแต่ละวัน)
• close = ราคาปิดของแต่ละวัน

field ที่เหลือเราจะไม่สนใจเลย เพราะเราจะเล่นกับราคาปิดแค่นั้น

ให้ดูกราฟ data close ของปี 2020

และนี่คือ 2021 เทียบกัน

อย่างที่เห็นครับ data ปี 2020 กับ 2021 นี่ ทิศทางบางจุดจะเหมือนกันคือขึ้นเป็น Bull Market เหมือนกัน แต่จะมีลักษณะ trend ระหว่างกลางที่ไม่เหมือนกัน ซึ่งเดี๋ยวเราจะมาลองดูกันว่ามันทำได้ดีกันแค่ไหน

มาเริ่ม Train สำนักที่ 3 LSTM กันก่อน นี่คือภาพอย่างง่ายของ LSTM ที่เราจะทำ

นี่คือภาพอย่างง่ายของสิ่งที่เราจะทำ

หลักการคือ เราจะทำการ normalized ข้อมูลก่อนเข้า Train หลังจากนั้น เราจะไล่ loop ข้อมูลราคาบนกราฟ ทุกๆ 5 วัน (วันที่ 1–5, 2–6, ไปเรื่อยๆ) แล้วเอาราคา 5 วันนั้นเข้า LSTM เพื่อทำการ train ข้อมูลและ tune parameter ออกมา และสุดท้าย ก็นำ model ที่ผ่านการ train แล้ว (ข้อมูลปี 2020) มา predict ราคาใหม่ (ในปี 2021) ใส่ dataframe กลับไป

code ที่ใช้

from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.optimizers import Adam

# Preprocess the data
scaler = MinMaxScaler()

# กำหนดให้ df_2020 คือข้อมูล Bitcoin รายวันปี 2020
# df_2021 คือข้อมูล Bitcoin รายวันปี 2021

df_2020['close_normalized'] = scaler.fit_transform(df_2020[['close']])

df_2021_test = pd.concat([df_2021, df_2020[0:5]])
df_2021_test['close_normalized'] = scaler.fit_transform(df_2021_test[['close']])

# Function to create sequences and labels for LSTM
def create_sequences(data, sequence_length):
    sequences = []
    labels = []

    for i in range(len(data) - sequence_length):
      if i + sequence_length >= len(data):
        break

      sequences.append(data[i:i+sequence_length])
      labels.append(data[i+sequence_length])

    return np.array(sequences), np.array(labels)

# LSTM parameters
sequence_length = 5  # Adjust this parameter to define the length of the input sequences
num_features = 1  # We are using only the 'price' column, so the number of features is 1
batch_size = 1
epochs = 10

# Create sequences and labels
train_sequences, train_labels = create_sequences(df_2020['close_normalized'].values, sequence_length)

# Build LSTM model
model = Sequential()
model.add(LSTM(50, input_shape=(sequence_length, num_features)))
model.add(Dense(1))
model.compile(optimizer=Adam(learning_rate=0.001), loss='mean_squared_error')

# Train the model
model.fit(train_sequences, train_labels, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[tensorboard_callback])

# Predict ปี 2021
test_sequences, test_labels = create_sequences(df_2021_test['close_normalized'].values, sequence_length)

# Use the model to predict Bitcoin prices
predicted_prices_normalized = model.predict(test_sequences)
predicted_prices = scaler.inverse_transform(predicted_prices_normalized)

df_2021['predicted_prices_lstm'] = predicted_prices

ผลลัพธ์ที่เกิดขึ้น ลองนำมา plot กราฟ เทียบราคาดู

ขอต๊ะไว้ประมาณนี้ก่อน เดี๋ยวเราจะกลับมาคุยกันต่อ ไป Train ต่อที่สำนักที่ 4 Deep Q RL กัน

ภาพอย่างง่ายของส่ิงที่เราจะทำ

เราจะทำการสร้าง Agent มาหนึ่งตัว (เดี๋ยวเราจะประกาศเป็น Class ใน python ไว้) และเราจะเพิ่ม Neuron network ตัวหนึ่ง (ใน code คือ model) ใส่ไว้เป็นเหมือนสมองของ Agent ที่จะพิจารณาว่า action 3 อย่างคือ ซื้อ, ขาย และ ถือ (a1, a2, a3 ตามภาพบน) อันไหนมีมูลค่าสูงสุดสำหรับ state นี้ ก็จะสามารถทำการเลือกใช้ action นั้นได้ และใส่ function สำหรับการ Train / Trade ไว้เพื่อให้ Agent ที่กำลังทดลอง Trade สามารถ tune parameter ระหว่างการ Trade ได้

โดยเริ่มต้นเราจะกำหนดค่า epsilon เอาไว้ เพื่อเป็นตัวบอกว่า ถ้าเกิด Agent นี้เพิ่งเริ่มเรียนรู้แรกๆ ก็มั่วไปเลย จนกว่าค่า epsilon จะเล็กลงเรื่อยๆจน Agent เราดีพอที่จะเอา Model มาลองใช้ Trade เองและงและ Tune ต่อได้ (อารมณ์ สุ่มลองผิดลองถูกก่อน ว่าแบบไหนกำไรมาก กำไรน้อย ถ้าเจอทางที่ใช่แล้ว ค่อยไปต่อกัน)

ผมจะแยกเป็น 2 section คือ สร้าง class AI Trader ที่เป็นตัวแทนของ Agent

import math
import random

import matplotlib.pyplot as plt
import pandas_datareader as data_reader
import tensorflow as tf

from tqdm import tqdm_notebook, tqdm
from collections import deque

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.optimizers import Adam

class AI_Trader():

  def __init__(self, state_size, action_space=3, model_name="AITrader"):
    self.state_size = state_size
    self.action_space = action_space
    self.memory = deque(maxlen=2000)
    self.inventory = []
    self.model_name = model_name
    self.model = self.model_builder()

    self.gamma = 0.95
    self.epsilon = 1.0
    self.epsilon_final = 0.01
    self.epsilon_decay = 0.995

  def model_builder(self):
    model = Sequential()
    model.add(Dense(units=32, activation='relu', input_dim=self.state_size))
    model.add(Dense(units=64, activation='relu'))
    model.add(Dense(units=128, activation='relu'))
    model.add(Dense(units=self.action_space, activation='linear'))
    model.compile(loss='mse', optimizer=Adam(learning_rate=0.001))
    return model

  def trade(self, state):
    if random.random() <= self.epsilon:
      return random.randrange(self.action_space)

    return np.argmax(self.model.predict(state)[0])

  def batch_train(self, batch_size):
    batch = []
    for i in range(len(self.memory) - batch_size + 1, len(self.memory)):
      batch.append(self.memory[i])

    for state, action, reward, next_state, done in batch:
      reward = reward
      if not done:
        reward = reward + self.gamma * np.amax(self.model.predict(next_state)[0])

      target = self.model.predict(state)
      target[0][action] = reward

      self.model.fit(state, target, epochs=1, verbose=0)

    if self.epsilon > self.epsilon_final:
      self.epsilon *= self.epsilon_decay

และ code สำหรับการ Train (โดยใช้จากข้อมูลปี 2020) มาทำการทดสอบการ Trade ซ้ำและ Tune parameter ไปเรื่อยๆ

data = list(df_2020['close'])[::-1]
data_samples = len(data) - 1

window_size = 10
episodes = 1

batch_size = 32

trader = AI_Trader(window_size)
trader.model.summary()

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

def state_creator(data, timestep, window_size):
  starting_id = timestep - window_size + 1

  if starting_id >= 0:
    windowed_data = data[starting_id:timestep+1]
  else:
    windowed_data = (-1*starting_id) * [data[0]] + list(data[0:timestep+1])

  state = []

  for i in range(window_size -1):
    state.append(sigmoid(windowed_data[i+1] - windowed_data[i]))

  return np.array([state])

# Train จากปี 2020
for episode in range(1, episodes + 1):

  print("Episode: {}/{}".format(episode, episodes))

  state = state_creator(data, 0, window_size + 1)

  total_profit = 0
  trader.inventory = []

  for t in tqdm(range(data_samples)):

    action = trader.trade(state)

    next_state = state_creator(data, t+1, window_size + 1)
    reward = 0

    if action == 1: #Buying
      trader.inventory.append(data[t])
      print("AI Trader bought: ", data[t])

    elif action == 2 and len(trader.inventory) > 0: #Selling
      buy_price = trader.inventory.pop(0)

      reward = max(data[t] - buy_price, 0)
      total_profit += data[t] - buy_price
      print("AI Trader sold: ", data[t], " Profit: " + str(data[t] - buy_price))

    if t == data_samples - 1:
      done = True
    else:
      done = False

    trader.memory.append((state, action, reward, next_state, done))

    state = next_state

    if done:
      print('=== Total profit = ', total_profit)

    if len(trader.memory) > batch_size:
      trader.batch_train(batch_size)

เมื่อ Train สำนักที่ 3 และ 4 เรียบร้อยตอนนี้เหล่า bot ของเราก็พร้อมสำหรับการแข่งขันครั้งนี้แล้ว

Backtesting — Setting การแข่งขันกันหน่อย

ผมจะสมมุติว่า ทั้ง 4 หน่อ (จาก 4 สำนัก) เป็นนัก day trade มือฉมัง โจทย์ของพวกเขาคือ

• มีเงินไม่จำกัด (เราจะปลดล็อคสกิลเงินอมตะให้กับทุกคน)
• จะเทรดให้มากที่สุดเท่าที่ทำได้ มีโอกาสซื้อต้องซื้อ มีโอกาสขายต้องขาย
• การซื้อขายทุกครั้งจะซื้อเต็มจำนวน 1 ชิ้นเสมอ เช่น ถ้าเกิดสัญญาณซื้อ เราจะถือว่าซื้อทั้งสิ้น 1 Bitcoin ที่ราคานั้น และการขายก็ขายเต็ม 1 Bitcoin เช่นเดียวกัน (เพื่อให้ง่ายตอนการคำนวน)
• หากครบปี ไม่สามารถเกิดสัญญาณขายได้จน Bitcoin หมด stock = ต้องเทขายทั้งหมดตอนวันสุดท้ายของปี
• กำไร / ขาดทุน วัดจาก จังหวะที่ขาย โดยเอา ราคา Bitcoin ตอนขาย — ราคา Bitcoin ตอนซื้อ และนำกำไร / ขาดทุน ทุกจุดรวมกัน เป็น กำไรสุทธิ (Profit) ของการแข่งขันครั้งนี้
• ผลลัพธ์จะบอกจำนวนการ Trade (จำนวนของการซื้อขายที่เกิดขึ้น) เอาไว้ด้วย แต่ในการทดลองนี้ ผมจะมองว่า การ Trade ทุกครั้ง “ไม่มีค่าธรรมเนียม” มาเกี่ยวข้อง

Strategry ของแต่ละวิธี

สำนักที่ 1 Technical Analysis

ผมจะใช้ EMA 10 (เนื่องจากข้อมูลเกลี่ยนแปลงไว เลยเอาเฉลี่ยแค่ 10 วันพอ) และ RSA มาผสมกัน โดย

• ซื้อ เมื่อ ราคาปิดของวันปัจจุบัน มากกว่า ราคา EMA 50 และ RSA > 60
• ขาย เมื่อ ราคาปิดของวันปัจจุบัน น้อยกว่า ราคา EMA 50 และ RSA < 20

code ที่ใช้

# Calculate Exponential Moving Average (EMA)
def calculate_ema(data, period):
    return data['close'].ewm(span=period, adjust=False).mean()

# Calculate Relative Strength Index (RSI)
def calculate_rsi(data, period=14):
    delta = data['close'].diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    return rsi


# ได้ราคา EMA ทั้งสายมา
df_ema = calculate_ema(df_2021, 10)

# ได้ราคา RSI ทั้งสายมา
df_rsa = calculate_rsi(df_2021)

ข้อมูลออกมาหน้าตาประมาณนี้ สีแดงคือกราฟ RSI (scale อยู่ทางด้านขวา) และ เส้นสีส้มคือ EMA 10

สำนักที่ 2 Fair price

เราจะกำหนดแต่ละ Parameter ในสมการตามนี้

• S (Strike price) = ราคาสุดท้ายของข้อมูลที่มี คูณ 3 (ซึ่งคูณ 3 นี้เป็นเลขที่เกิดจากการทดลองของผมเลยนะครับ)
• r (Risk free rate) = 0.05 (fix ตามหลายๆแหล่งแนะนำ)
• T (Time to expiration in year) = 1 / 365 (ตัวเลขที่ใส่ตรงนี้เป็นเลขปี ผมเลยเอาหาร 365 ให้กลายเป็น 1 วันที่สามารถเทรดได้)
• σ (Volatility) = sd ของ percent ของ close price ทั้งหมดของข้อมูล

code ที่ใช้

from mibian import BS

# Function to calculate the fair price of a call option using Black-Scholes model
def calculate_option_price(current_price, strike_price, time_to_expiry, risk_free_rate, volatility):
    option = BS([current_price, strike_price, risk_free_rate, time_to_expiry], volatility=volatility)
    return option.callPrice, option.putPrice

# Function to calculate annualized volatility
def calculate_volatility(prices):
    returns = prices.pct_change()
    volatility = returns.std()
    return volatility

# Calculate annualized volatility
volatility = calculate_volatility(df_2021['close'])
print("volatility", volatility)

# Black-Scholes parameters
spot_price = df_2021['close'].iloc[-1]  # Use the last price as the spot price
strike_price = spot_price * 3
risk_free_rate = 0.05  # Set the risk-free rate based on market conditions
time_to_expiry = 1 / 365  # Assuming a one-year option

# Add new columns to the DataFrame to store call and put option prices
df_2021['Call_Option_Price'] = 0
df_2021['Put_Option_Price'] = 0

i = 0
# Loop through the DataFrame and calculate option prices for each date
for index, row in df_2021.iterrows():
    current_price = row['close']
    call_option_price, put_option_price = calculate_option_price(current_price, strike_price, time_to_expiry, risk_free_rate, volatility)

    df_2021.at[index, 'call_option_price'] = call_option_price
    df_2021.at[index, 'put_option_price'] = put_option_price
    i += 1

ทีนี้ก่อนจะ set strategy trade ผมลองเอามา plot graph ดู

ปรากฎว่า call action (ที่ควรจะเป็นสัญญาณซื้อ) ผมทำยังไงก็ไม่สามารถ plot ออกมาได้ และ กว่าผมจะเจอ put acion (ที่ควรจะเป็นสัญญาณบอกว่าขาย) ก็ต้องใส่ strike price ถึงคูณ 3 อย่างที่บอกไปตอนแรก ผมเลยตัดสินใจสร้างสัญญาณซื้อขายแบบ “มั่วๆ” ตามสไตล์ของผมเลยคือ

• ซื้อ เมื่อ ราคาน้อยกว่าราคา Put price
• ขาย เมื่อ ราคามากกว่าราคา Put price

สำนักที่ 3 LSTM

ตอนแรกผมพยายาม set ให้ไอเดียใกล้เคียงกันกับข้อที่ 2 คือ ซื้อเมื่อราคาถูกกว่าราคาทำนาย (แปลว่ามีแนวโน้มจะราคาขึ้น) และ ขายเมื่อราคาต่ำกว่าราคาทำนาย (แปลว่ามีแนวโน้มจะราคาลง) ปรากฎว่า “ขาดทุนเละเทะ” ซึ่งผมคิดว่ามันน่าจะไม่ได้สร้างมาเพื่อจุดประสงค์ในการทำแบบนี้ ผมเลยก็ตัดสินใจเปลี่ยนเป็น

• ซื้อ เมื่อ ราคา “ทำนาย” ของวันปัจจุบัน มากกว่า ราคา EMA 10 และ RSA > 60
• ขาย เมื่อ ราคา “ทำนาย” ของวันปัจจุบัน น้อยกว่า ราคา EMA 10 และ RSA < 20

โดยใช้ราคาทำนายมาทำกราฟ EMA 10 และ RSA แทน ก็คือเอาสำนักที่ 1 มาใช้แต่เปลี่ยนจากราคาปิดจริง เป็น ราคาทำนายแทนนั่นเอง

ส่วนสำนักที่ 4 Deep Q RL

นั่นมันคิดจุดซื้อขายของมันเองอยู่แล้ว ผมคงปล่อยให้ Agent มันตัดสินใจเลยว่า

• ซื้อ เมื่อมันว่าอยากซื้อ
• ขาย เมื่อมันว่าอยากขาย

ตามนั้นเลย 555

และนี่คือตารางสรุปทั้ง 4 วิธี

ทดสอบกันแต่ละวิธี

ได้เวลาที่เราจะลอง run backtracking test ของแต่ละสำนักกันและ

สำนักที่ 1 — Technical Analysis

code ที่ใช้

# Bot action for 1.
# ถ้า RSA น้อยกว่า 20 และ กราฟต่ำกว่า EMA = ซื้อ (จะซื้อเรื่อยๆจนหมด)
# ถ้า RSA มากกว่า 60 และ กราฟอยู่สูงกว่า EMA = ขาย (จะขายเรื่อยๆจนหมด)

inventories = []
profit = 0
trade_count = 0
last_price = -1

for i in range(len(df_2021) - 1, 0, -1):
  close_price = df_2021.iloc[i]['close']
  ema_price = df_ema.iloc[i]
  last_price = close_price
  if df_rsa.iloc[i] <= 20 and close_price <= ema_price:
    inventories.append(close_price)
  elif len(inventories) > 0 and df_rsa.iloc[i] >= 60 and close_price >= ema_price:
    selected_price = inventories.pop(0)
    profit += (close_price - selected_price)
    # print('sell date = ', df_2020.iloc[i]['date'], 'close at', selected_price, close_price)
    trade_count += 1

print('จำนวน Bitcoin ที่เหลือวันสุดท้าย', len(inventories))
print('ราคาซื้อที่เหลืออยู่:', inventories)

while len(inventories) > 0:
  selected_price = inventories.pop(0)
  profit += (last_price - selected_price)
  trade_count += 1

print('กำไร = ', profit, ', จำนวนการ Trade = ', trade_count)

ผลที่เกิดขึ้น

จำนวน Bitcoin ที่เหลือตอนสุดท้าย 0
กำไร =  548793.18 , จำนวนการ Trade =  25

สำนักที่ 2 — Black Schole model

code ที่ใช้

# Bot for action 2
# ตามหลักเราควรใช้ Call action ในการหาราคาเข้าซื้อ
# แต่เนื่องจากเราตีกราฟ Call action ออกมาไม่ได้ (ซึ่งไม่แน่ใจว่าทำไมเหมือนกัน)
# ใช้ Put action แล้วกลับสัญญาณแทน โดย ถ้า
# - ราคาน้อยกว่า Put action = ซื้อ
# - ราคามากกว่า Put action = ขาย

inventories = []

profit = 0
trade_count = 0
last_price = -1

for i in range(len(df_2021) - 1, 0, -1):
  close_price = df_2021.iloc[i]['close']
  last_price = close_price
  theorical_price = df_2021.iloc[i]['put_option_price']
  if close_price < theorical_price:
    inventories.append(close_price)
  elif len(inventories) > 0 and close_price > theorical_price:
    select_price = inventories.pop(0)
    profit += close_price - select_price
    trade_count += 1

print('จำนวน Bitcoin ที่เหลือตอนสุดท้าย', len(inventories))
print('ราคาซื้อที่เหลืออยู่:', inventories)

while len(inventories) > 0:
  select_price = inventories.pop(0)
  profit += last_price - select_price
  trade_count += 1

print('กำไร =', profit, 'จำนวนการ Trade =', trade_count)

ผลลัพธ์ที่เกิดขึ้น

จำนวน Bitcoin ที่เหลือตอนสุดท้าย 0
กำไร = 2205825.16 จำนวนการ Trade = 131

สำนักที่ 3 — Deep Learning

Code ที่ใช้

# bot for action 3
# ซื้อเมื่อ ราคา prediect > EMA 10 และ RSI > 60
# ขายเมื่อ ราคา prediect < EMA 10 และ RSI < 20

# Calculate Exponential Moving Average (EMA)
def calculate_ema(data, period):
    return data['predicted_prices_lstm'].ewm(span=period, adjust=False).mean()

# Calculate Relative Strength Index (RSI)
def calculate_rsi(data, period=14):
    delta = data['predicted_prices_lstm'].diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    return rsi

profit = 0
inventories = []
trade_count = 0

df_ema_lstm = calculate_ema(df_2021, 10)
df_rsi_lstm = calculate_rsi(df_2021)

inventories = []
profit = 0
trade_count = 0
last_price = -1

for i in range(len(df_2021) - 1, 0, -1):
  close_price = df_2021.iloc[i]['close']
  predict_price = df_2021.iloc[i]['predicted_prices_lstm']
  ema_price = df_ema_lstm.iloc[i]
  last_price = close_price

  if df_rsi_lstm.iloc[i] <= 20 and predict_price <= ema_price:
    inventories.append(close_price)
  elif len(inventories) > 0 and df_rsi_lstm.iloc[i] >= 60 and predict_price >= ema_price:
    selected_price = inventories.pop(0)
    profit += (close_price - selected_price)
    # print('sell date = ', df_2020.iloc[i]['date'], 'close at', selected_price, close_price)
    trade_count += 1

print('จำนวน Bitcoin ที่เหลือตอนสุดท้าย', len(inventories))
print('ราคาซื้อที่เหลืออยู่:', inventories)
print('ราคา ณ วันสุดท้าย:', close_price)

while len(inventories) > 0:
  selected_price = inventories.pop(0)
  profit += (last_price - selected_price)
  trade_count += 1

print('กำไร =', profit, ',จำนวนการ Trade = ', trade_count)

ผลลัพธ์ที่เกิดขึ้น

จำนวน Bitcoin ที่เหลือตอนสุดท้าย 2
ราคาซื้อที่เหลืออยู่: [62301.59, 61932.3]
ราคา ณ วันสุดท้าย: 47150.71
กำไร = 746805.7599999998 ,จำนวนการ Trade =  88

** แน่นอนครับ มันเป็น AI ทุกรอบที่ run model มีแนวโน้มว่าเราจะได้คำตอบของราคาทำนายมาไม่เหมือนกัน ไม่ต้องแปลกใจหากลองนำ code ไปรันเองแล้วได้ผลลัพธ์ไม่ตรงกันนะ

สำนักที่ 4— Deep Q Reinforcement learning

Code ที่ใช้

# สนามต่อสู้จริง 2021
data_2021 = list(df_2021['close'])[::-1]
data_samples_2021 = len(data) - 1

state = state_creator(data_2021, 0, window_size + 1)

profit = 0
trade_count = 0

trader.inventory = []

for t in tqdm(range(data_samples_2021)):
  action = trader.trade(state)

  if action == 1: #Buying
    trader.inventory.append(data_2021[t])
    print("AI Trader bought: ", data_2021[t])

  elif action == 2 and len(trader.inventory) > 0: #Selling
    buy_price = trader.inventory.pop(0)

    reward = max(data[t] - buy_price, 0)
    profit += data_2021[t] - buy_price
    trade_count += 1
    print("AI Trader sold: ", data_2021[t], " Profit: " + str(data_2021[t] - buy_price) )

  # go to next state
  state = state_creator(data, t+1, window_size + 1)

  if t == data_samples - 1:
    done = True
  else:
    done = False

  if done:
    print('จำนวน Bitcoin ที่ยังเหลือตอนสุดท้าย', len(trader.inventory))
    print('ราคาซื้อที่เหลืออยู่:', trader.inventory)

    while len(trader.inventory) > 0:
      last_price = data_2021[-1]
      buy_price = trader.inventory.pop(0)
      profit += last_price - buy_price

    print('กำไร = ', profit, 'จำนวนการ Trade = ', trade_count)

ผมจะเทรนเพียงแค่ 3 episode พอ เนื่องจากการเทรนแต่ละรอบใช้เวลานานพอสมควร

ผลลัพธ์ที่เกิดขึ้น

จำนวน Bitcoin ที่เหลือตอนสุดท้าย 8
กำไร =  30494.169999999955 จำนวนการ Trade = 38

เอาจริงๆนะครับ ผลลัพธ์ของสำนักที่ 4 นี่แกว่งมาก ซึ่งผมคิดว่าน่าจะเกิดจาก Model ที่ผมใช้ด้ว ผมลองเทรนสลับกันไปมา ได้กำไร ขาดทุน สลับกันตลอด

ดังนั้นผู้ชนะในการแข่งขันครั้งนี้คือ สำนักที่ 2 — Black Schole model !

ทุกคนสามารถเข้าไปสำรวจ code เราได้ที่นี่ (เผื่อว่าใครอาจจะเจอว่าเราคำนวนสิ่งใดไม่ถูกต้องได้)

https://colab.research.google.com/drive/1f2vIf3qUwBHspx8Q1ESG2bhL8oLQxqty?usp=sharing

อย่าลืมนะครับทุกคน ผลการทดลองนี้ ผมใช้ข้อมูลจาก Bitcoin ปี 2021 ซึ่งถือได้ว่าเป็นยุคทองของ Bitcoin ที่มีการราคาพุ่งขึ้นไปสูงมาก เอาจริงๆผมลอง sample หลายวิธีก็เจอว่าได้กำไรเกือบทุกวิธีเลย

เรียนรู้อะไรจากเรื่องราวนี้บ้าง

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

สิ่งที่เกิน Expected ผมไปมาก (และทำเอาผมต้องมาเช็ค code หลายรอบมาก) คือการที่ Model คำนวน อย่าง Black Schole model สามารถเอาชนะการแข่งขันครั้งนี้ได้ เพียงแค่ผมลองปรับ factor ไปมาแค่นั้น ผมเลยคิดว่า สิ่งที่จะทำให้เราสามารถสร้าง Bot trade ที่แข่งแกร่งออกมาได้จริง มันจะอยู่ที่ผลจากการทดลองออกมาล้วนๆเลย เพราะท้ายที่สุด ถ้าผมลองปรับ Model ของ Deep learning หรือ Deep Q RL Train ให้แข็งแกร่งมากพอ มันอาจจะเอาชนะในตลาดที่สุดก็ได้นะ

Reference เพิ่มเติม

• https://www.investopedia.com/terms/b/blackscholes.asp
• https://www.mlq.ai/deep-reinforcement-learning-for-trading-with-tensorflow-2-0/
• https://www.freecodecamp.org/news/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc/
• https://medium.com/@nutorbitx/reinforcement-learning-%E0%B8%AA%E0%B8%AD%E0%B8%99-ai-%E0%B8%94%E0%B9%89%E0%B8%A7%E0%B8%A2-q-learning-%E0%B8%81%E0%B8%B1%E0%B8%99%E0%B8%94%E0%B8%B5%E0%B8%81%E0%B8%A7%E0%B9%88%E0%B8%B2-cb5e0f4a2cac