การสร้างซีรีส์ผลตอบแทนด้วยข้อมูล Forex ของ Polygon

ในบทความนี้เราจะเข้าถึง Polygon API และดาวน์โหลดข้อมูล Forex รายวันเป็นระยะเวลา 1 เดือน เราจะแสดงให้คุณเห็นวิธีเข้าถึง API โดยสร้างฟังก์ชัน Python ที่สามารถปรับให้เข้ากับการดึงข้อมูล FX สำหรับคู่ต่างๆ ในช่วงเวลาที่แตกต่างกันได้อย่างง่ายดาย เราจะสร้างและแสดงผลชุดข้อมูลผลตอบแทนด้วย Pandas ด้วย บทความนี้เป็นส่วนหนึ่งของซีรีส์เกี่ยวกับข้อมูล Forex ในบทความถัดไปเราจะใช้ความผันผวนที่เกิดขึ้นจริงในการฝึกโมเดลการเรียนรู้ของเครื่องและคาดการณ์ระบอบตลาด

เพื่อที่จะติดตามโค้ดในบทแนะนำนี้ คุณจะต้องมี:

• Python 3.9 
• Matplotlib 3.5 
• Pandas 1.4 
• Requests 2.27 

เราขอแนะนำให้คุณดูซีรีส์การวิจัยสำหรับผู้เริ่มต้นอาชีพของเราเพื่อสร้างสภาพแวดล้อมการซื้อขายอัลกอริธึมภายใน Jupyter Notebook เราจะเริ่มต้นด้วยการดูว่าตลาด Forex แบ่งออกเป็นอย่างไรในปี 2023

Polygon.io และตลาด Forex 

ตลาดฟอเร็กซ์ประกอบด้วยคู่เงินที่มีการซื้อขายสูงหรือคู่เงินหลัก และคู่เงินที่มีการซื้อขายน้อยหรือคู่เงินแปลกใหม่ ปัจจุบัน ปริมาณการซื้อขายฟอเร็กซ์ส่วนใหญ่ดำเนินการในคู่เงินหลักสามคู่ ได้แก่ EURUSD, USDJPY และ GBPUSD อย่างไรก็ตาม ยังมีคู่สกุลเงินอื่นๆ อีกมากมาย

ในความเป็นจริง Polygon มีข้อมูลเกี่ยวกับคู่เงินต่างประเทศ 1000 คู่ Polygon.io ก่อตั้งขึ้นในปี 2006 และ "สร้างโดยนักพัฒนาสำหรับนักพัฒนา" พวกเขามุ่งมั่นที่จะให้การเข้าถึงข้อมูลประวัติศาสตร์และข้อมูลเรียลไทม์ที่แม่นยำที่สุดแก่ผู้พัฒนาอย่างราบรื่น Polygon มี API สำหรับข้อมูลหุ้น ตัวเลือก สกุลเงินดิจิทัล และฟอเร็กซ์ พวกเขามีการครอบคลุมตลาด 100% สำหรับหุ้นของสหรัฐอเมริกา โดยมีข้อมูลจากตลาดหลักทรัพย์ทั้งหมดในสหรัฐอเมริกาและสถานที่ซื้อขายนอกตลาดหลักทรัพย์ (OTC) ข้อมูลตัวเลือกของพวกเขารวมถึงสัญญาตัวเลือกที่ใช้งานอยู่และประวัติของสัญญาตัวเลือก, กรีกส์ และความผันผวนที่คาดการณ์ไว้ นอกจากนี้ Polygon ยังมีสัญลักษณ์สกุลเงินดิจิทัล 166 ตัวที่มีข้อมูลจากตลาดแลกเปลี่ยนสี่แห่ง รวมถึง Coinbase และ Kraken สำหรับข้อมูล Forex พวกเขามีการอัปเดตแบบ tick by tick สำหรับคู่สกุลเงินทั้งหมด 1,000 คู่ ภายใต้ใบอนุญาตการใช้งานส่วนบุคคล ข้อมูล Crypto และ Forex จะได้รับใบอนุญาตร่วมกันในแพ็คเกจ Basic (ฟรี) หรือ Currencies Starter (พรีเมียม) การสมัครสมาชิก Basic Currencies ให้คุณเข้าถึงการเรียก API สูงสุด 5 ครั้งต่อนาที ข้อมูลสิ้นสุดวันที่ในช่วงเวลาต่างๆ และมีประวัติสูงสุด 2 ปี ข้อมูลอ้างอิง และแท่งรวม

ในบทแนะนำนี้ เราจะใช้ Polygon API เพื่อรับข้อมูล Forex รายวัน (ทุกนาที) เป็นระยะเวลา 1 เดือน สำหรับคู่เงินหลักและคู่เงินแปลกใหม่ เราจะแสดงให้คุณเห็นวิธีการดึงข้อมูลจาก API โดยใช้ไลบรารี Python อย่าง simplejson และ requests เราจะสร้างชุดข้อมูลผลตอบแทนสำหรับคู่เงินทั้งสองโดยใช้ Pandas และสำรวจข้อผิดพลาดบางประการที่อาจเกิดขึ้นเมื่อทำงานกับและสร้างกราฟข้อมูลเวลา มาเริ่มต้นกันด้วยการสมัครสมาชิก Basic Currencies กันเถอะ สิ่งนี้ฟรีและจะให้คุณได้รับ API key ที่คุณสามารถใช้เพื่อเข้าถึงข้อมูล Forex ได้

การใช้ Polygon API 

ไปที่เว็บไซต์ Polygon และคลิกที่รับ API key ฟรีของคุณ เมื่อคุณลงทะเบียนและเข้าสู่ระบบแล้ว คุณสามารถดู API key ของคุณได้ในเมนูดรอปดาวน์ของ Dashboard โดยเลือก API Keys มันจะแสดงให้คุณเห็นเมื่อคุณดูเอกสารประกอบด้วย เอกสารของ Polygon นั้นละเอียดและใช้งานง่ายมาก คุณสามารถสร้างคำขอ API ของคุณโดยใช้เมนูแบบเลื่อนลงบนเว็บไซต์ เมื่อคุณเลือกตัวเลือกที่ต้องการแล้ว URL ของ API จะปรากฏให้คุณด้านล่างของเมนูแบบเลื่อนลง ลองดูเอกสารเริ่มต้นของพวกเขาเพื่อดูสิ่งนี้ในทางปฏิบัติ

หนึ่งในสิ่งแรกที่ควรสังเกตเกี่ยวกับพารามิเตอร์ forexTicker ในจุดสิ้นสุดของ API ข้อมูลตลาดคือคู่ FX ทั้งหมดใน Polygon จะมีคำว่า C: นำหน้า ดังนั้นสำหรับ EURUSD เราจะต้องใช้ C:EURUSD ในการเรียก API หากคุณไม่แน่ใจเกี่ยวกับสัญลักษณ์ที่ถูกต้องที่ควรใช้ คุณสามารถสอบถามข้อมูลจาก Reference Data Endpoint โดยใช้พารามิเตอร์ Tickers ที่นี่คุณสามารถระบุตลาดที่คุณสนใจ (FX, Crypto, หุ้น ฯลฯ) และโดยการเว้นพารามิเตอร์ ticker ว่างไว้ คุณสามารถรับ ticker ทั้งหมดสำหรับตลาดนั้นได้ การตั้งค่าเริ่มต้นสำหรับพารามิเตอร์ limit จะคืนผลลัพธ์ 100 รายการ ซึ่งคุณสามารถเปลี่ยนเป็นสูงสุด 1000 รายการได้ ตอนนี้ที่เราได้รู้ว่า ticker ถูกจัดรูปแบบอย่างไรแล้ว มาดูว่า API call ที่เหลือจะถูกสร้างขึ้นอย่างไรบ้าง

การเรียก API แต่ละครั้งไปยังจุดสิ้นสุดของข้อมูลตลาดจะเริ่มต้นด้วยที่อยู่ https เดียวกัน https://api/polygon.io/v2/aggs/ และทุกการเรียก API จะสิ้นสุดด้วยคีย์ API ที่ไม่ซ้ำกันของคุณ สิ่งนี้กระตุ้นให้สร้างตัวแปรในโค้ดของเราเพื่อป้องกันการทำซ้ำ ด้านล่างนี้เราจะเริ่มสร้างโค้ดที่จะติดต่อกับ API

import json
import matplotlib.pyplot as plt
import pandas as pd
import requests

POLYGON_API_KEY = 'YOUR_API_KEY'
HEADERS = {
    'Authorization': 'Bearer ' + POLYGON_API_KEY 
}
BASE_URL = 'https://api.polygon.io/v2/aggs'

ที่นี่เราได้สร้างตัวแปรทั่วโลกสามตัวซึ่งสามารถเข้าถึงได้โดยฟังก์ชันทั้งหมดที่เราจะสร้างในภายหลังในโค้ด POLYGON_API_KEY จะเก็บ API key ของคุณไว้เพื่อที่คุณจะไม่ต้องเขียนมันซ้ำแล้วซ้ำอีก พจนานุกรม HEADERS เก็บข้อมูลส่วนหัวการอนุญาตตามที่แสดงในเอกสารเริ่มต้นของ Polygon สุดท้ายเรามี BASE_URL ซึ่งเก็บจุดเริ่มต้นของการเรียก API ตอนนี้เราพร้อมที่จะสร้างฟังก์ชันแรกของเราซึ่งจะกำหนดรูปแบบการเรียก API สำหรับข้อมูล Forex รายนาที

pg_tickers = ["C:EURUSD", "C:MXNZAR"]

def get_fx_pairs_data(pg_tickers):
    start = '2023-01-01'
    end = '2023-01-31'
    multiplier = '1'
    timespan = 'minute'
    fx_url = f"range/{multiplier}/{timespan}/{start}/{end}?adjusted=true&sort=asc&limit=50000"
    fx_pairs_dict = {}
    for pair in pg_tickers:
        response = requests.get(
            f"{BASE_URL}ticker/{pair}/{fx_url}", 
            headers=HEADERS
        ).json()
        fx_pairs_dict[pair] = pd.DataFrame(response['results'])
    return fx_pairs_dict

ฟังก์ชัน get_fx_pairs_data(pg_tickers) รับพารามิเตอร์ pg_tickers นี่เป็นเพียงรายการของตัวย่อที่สามารถกำหนดได้ในเซลล์ด้านบนของฟังก์ชันหากใช้โน้ตบุ๊กหรือกำหนดใน __main__ รายการนี้สามารถขยายได้ง่าย แต่โปรดทราบว่าการใช้คีย์ API ฟรีจะให้คุณเพียง 5 การเรียก API ต่อหนึ่งนาทีเท่านั้น ที่นี่เราได้เลือกใช้คู่สกุลเงินหลัก EURUSD (ยูโร:ดอลลาร์สหรัฐ) และคู่สกุลเงินแปลก MZXZAR (เปโซเม็กซิกัน:แรนด์แอฟริกาใต้) เลือกสัญลักษณ์ใดก็ได้ตามที่คุณต้องการ ภายในฟังก์ชันของเรา เราได้กำหนดตัวแปรต่อไปนี้ start, end, multiplier, timespan สิ่งนี้ช่วยให้เราสามารถเปลี่ยนช่วงและระยะเวลาของข้อมูลที่เราได้รับได้อย่างง่ายดาย จากนั้นเราจะรวมส่วนต่างๆ ของ URL เข้าด้วยกันในตัวแปร fx_url จากนั้น (ตามที่เราได้ทำในบทแนะนำก่อนหน้านี้) เราสามารถสร้าง fx_pairs_dict ของเรา ซึ่งเป็นพจนานุกรมของ DataFrames โดยมี ticker เป็นกุญแจและข้อมูลเป็นค่า ตรวจสอบบทความ tiingo ของเราเพื่อข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ เราสามารถเรียกใช้ฟังก์ชันตามด้านล่างนี้ได้แล้ว และข้อมูลของเราจะถูกเก็บไว้ในตัวแปร fx_pairs_dict ของเรา

fx_pairs_dict = get_fx_pairs_data(pg_tickers)
Python

ข้อมูลสำหรับแต่ละคู่สามารถเข้าถึงได้โดยการเรียกใช้ตัวแปร dict พร้อมกับคีย์สำหรับคู่ fx เช่น fx_pairs_dict['C:EURUSD']

รายการเนื้อหาของคอลัมน์ทั้งหมดสามารถดูได้ในเอกสารของ Polygon คอลัมน์ที่เราสนใจในขณะนี้รวมถึง c ราคาปิดที่ปรับแล้ว และ t เวลาประทับเวลา ดังที่คุณเห็น timestamp เป็นค่าของ Unix Msec ฟังก์ชันถัดไปของเราจะแปลงค่านี้เป็นวันที่และเวลาจริงและตั้งเป็นดัชนี

def format_fx_pairs(fx_pair_dict):
    for pair in fx_pairs_dict.keys():
        fx_pairs_dict[pair]['t'] = pd.to_datetime(fx_pairs_dict[pair]['t'],unit='ms')
        fx_pairs_dict[pair] = fx_pairs_dict[pair].set_index('t')
    return fx_pairs_dict

ตอนนี้เราสามารถเรียกใช้ฟังก์ชันของเราและส่งผ่าน fx_pairs_dict ของเราได้ดังนี้: formatted_fx_dict = format_fx_pairs(fx_pairs_dict) สิ่งนี้จะบันทึก DataFrame ที่จัดรูปแบบแล้วลงในตัวแปรที่เรียกว่า formatted_fx_dict

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

for pair in formatted_fx_pairs:
formatted_fx_pairs[pair].plot(y='c', figsize=(16, 10)) 

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

ปรากฏการณ์เดียวกันนี้เห็นได้ในคู่เงินแปลก MZXZAR เนื่องจากคู่สกุลเงินนี้ไม่ได้มีการซื้อขายบ่อยนัก คุณจึงสามารถเห็นการประมาณค่าที่เกิดขึ้นบ่อยขึ้นมาก

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

มีตัวเลือกหลายอย่างที่คุณสามารถพิจารณาเพื่อจัดการกับปัญหาประเภทนี้เมื่อทำงานกับข้อมูลอนุกรมเวลา หากคุณต้องการให้ดัชนีสะท้อนฟังก์ชันการพล็อตและมีดัชนี DateTime ที่สมบูรณ์ Pandas มีตัวเลือกในการเติมข้อมูลย้อนหลังหรือเติมข้อมูลล่วงหน้าเมื่อสร้างดัชนี การเติมข้อมูลย้อนหลังจะใช้ค่าที่ไม่ใช่ Nan ถัดไปในคอลัมน์และเติมเซลล์ว่างย้อนกลับ เมื่อทำงานกับข้อมูลเชิงเวลา เช่น ข้อมูลทางการเงิน คุณไม่ควรย้อนกลับข้อมูลราคาของคุณ สิ่งนี้สร้างอคติแบบมองไปข้างหน้า ทำให้กลยุทธ์การซื้อขายใดๆ สามารถเข้าถึงข้อมูลในอนาคตได้ ซึ่งสัมพันธ์กับจุดเวลาปัจจุบัน การเติมข้อมูลข้างหน้าใช้ราคาก่อนหน้าเพื่อเติมข้อมูลในเซลล์ที่มีค่า NaN สิ่งนี้ไม่ทำให้เกิดการล่วงหน้า แต่คุณควรระวังว่าจะใช้หรือไม่ใช้มัน

มีวิธีการเติมข้อมูลย้อนหลังและเติมข้อมูลล่วงหน้าหลายวิธี คุณไม่จำเป็นต้องคัดลอกราคาก่อนหน้าหรือราคาถัดไปเพียงอย่างเดียว คุณสามารถหาค่าเฉลี่ยหรือใช้ฟังก์ชันต่างๆ หลายตัวในการคำนวณค่าได้ อย่างไรก็ตาม อาจไม่เหมาะสมที่จะทำการประมาณค่าข้อมูล นี่คือจุดที่คุณต้องคิดเกี่ยวกับข้อมูลและคำถามที่คุณกำลังถาม ถามว่าการเปลี่ยนแปลงที่คุณกำลังจะทำเป็นการสะท้อนสิ่งที่เกิดขึ้นจริงกับข้อมูลหรือไม่ ข้อมูลที่คุณกำลังทำงานด้วยควรจะสมบูรณ์หรือไม่? หรือจุดข้อมูลที่หายไปนั้นมีความหมายอะไรหรือเปล่า? ในกรณีนี้เรากำลังจัดการกับราคาปิดที่แทนการซื้อขายจริงของคู่สกุลเงินต่างประเทศ โดยการเติมข้อมูลไปข้างหน้า เราจะสร้างการซื้อขายที่ยังไม่เกิดขึ้น ในกรณีนี้ การเพิกเฉยหรือเอาข้อมูลที่หายไปออกจากกราฟจะปลอดภัยกว่า

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

def create_str_index(formatted_fx_dict):
    fx_pair_str_ind = {}
    for pair in formatted_fx_dict.keys():
        fx_pair_str_ind[pair] = formatted_fx_dict[pair].set_index(
            formatted_fx_dict[pair].index.to_series().dt.strftime(
                '%Y-%m-%d-%H-%M-%S'
            )
        )
    return fx_pair_str_ind 

เราสามารถบันทึกคู่ที่มีการจัดทำดัชนีด้วยสตริงลงในตัวแปรโดยเรียก fx_pair_str_ind = create_str_index(formatted_fx_dict) ถ้าเราวาดกราฟราคาปิดอีกครั้ง เราจะเห็นว่าการประมาณค่าถูกลบออกไปแล้ว

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

def create_returns_series(fx_pairs_str_ind):
    for pair in fx_pairs_str_ind.keys():
    fx_pairs_str_ind[pair]['rets'] = fx_pairs_str_ind[pair]['c'].pct_change()
    return fx_pair_str_ind 

เราสามารถบันทึกพจนานุกรม DataFrame ที่จัดรูปแบบเสร็จสมบูรณ์ของเราไปยังตัวแปร fx_returns_dict ได้แล้วโดยใช้โค้ดต่อไปนี้

fx_returns_dict = creat_returns_series(fx_pair_str_ind) 

เราสามารถสร้างกราฟชุดผลตอบแทนสำหรับแต่ละคู่ได้แล้ว ฟังก์ชันต่อไปนี้สามารถใช้สร้างรูปย่อยสำหรับคู่ FX ได้จำนวนเท่าใดก็ได้ คุณเพียงแค่ต้องเปลี่ยนรูปทรงของอาร์เรย์ที่ส่งคืนโดย matplotlib ในการเรียก plt.subplots(rows, cols, *kwargs)

def plot_returns_series(fx_pairs_str_ind):
    fig, ax = plt.subplots(1,2, figsize=(16, 10), squeeze=False)

    for idx, fxpair in enumerate(fx_pairs_str_ind.keys()):
        row = (idx//2)
        col = (idx%2)
                    
        ax[row][col].plot(fx_pairs_str_ind[fxpair].index, fx_pairs_str_ind[fxpair]['rets'])
        ax[row][col].set_xticks('')
        ax[row][col].set_title(fxpair)
    fig.suptitle("Returns Series 1/1/2023 - 31/01/23")
    plt.show() 

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

อ้างอิง :Creating a Returns Series with Polygon's Forex Data

จาก https://www.quantstart.com/articles/creating-a-returns-series-with-polygons-forex-data/