พื้นฐาน

บทนำ: การผสานเทคโนโลยีกับกลยุทธ์การลงทุนในหุ้นปันผลสูงพื้นฐานดี ปี 2564

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

การลงทุนในหุ้นปันผลสูง (High Dividend Stocks) โดยเฉพาะหุ้นที่มีพื้นฐานดี (Fundamentally Strong Stocks) เป็นกลยุทธ์ที่ได้รับความนิยมมายาวนาน เพราะนอกจากจะได้รับผลตอบแทนจากส่วนต่างราคา (Capital Gain) แล้ว ยังได้รับเงินปันผลเป็นกระแสเงินสดสม่ำเสมอ แต่ความท้าทายคือการคัดกรองหุ้นจำนวนกว่า 800 ตัวในตลาดหลักทรัพย์ฯ ให้เหลือเพียงไม่กี่ตัวที่ตรงตามเกณฑ์ ซึ่งเทคโนโลยีสามารถเข้ามาช่วยลดภาระนี้ได้อย่างมีนัยสำคัญ

1. พื้นฐานการวิเคราะห์หุ้นปันผลสูงด้วย Python และ Pandas

ภาษา Python เป็นเครื่องมืออันทรงพลังสำหรับนักลงทุนสายเทค ด้วยไลบรารีอย่าง Pandas ที่ช่วยจัดการข้อมูลตาราง (DataFrame) ได้อย่างมีประสิทธิภาพ เราสามารถเขียนสคริปต์เพื่อโหลดข้อมูลงบการเงิน อัตราการจ่ายปันผล และอัตราส่วนทางการเงินอื่นๆ มาวิเคราะห์พร้อมกันได้

1.1 การติดตั้งและตั้งค่า environment

ก่อนเริ่มเขียนโค้ด ต้องติดตั้งไลบรารีที่จำเป็นผ่าน pip โดยเปิด terminal หรือ command prompt แล้วรันคำสั่งต่อไปนี้:

pip install pandas numpy yfinance requests beautifulsoup4 openpyxl

คำอธิบาย: yfinance ใช้ดึงข้อมูลหุ้นจาก Yahoo Finance, requests และ beautifulsoup4 ใช้สำหรับ web scraping, openpyxl ใช้สำหรับ export ข้อมูลเป็น Excel

1.2 การดึงข้อมูลราคาและปันผลย้อนหลัง

ตัวอย่างโค้ดด้านล่างแสดงวิธีการดึงข้อมูลราคาปิดรายวันและอัตราเงินปันผลของหุ้นไทย โดยใช้ ticker ที่ลงท้ายด้วย “.BK” (สำหรับตลาดหลักทรัพย์ฯ):

import yfinance as yf
import pandas as pd
from datetime import datetime

# กำหนดรายชื่อหุ้นที่สนใจ (ตัวอย่าง)
tickers = ['ADVANC.BK', 'CPALL.BK', 'PTT.BK', 'SCB.BK', 'SCC.BK']

# สร้าง DataFrame ว่างสำหรับเก็บผลลัพธ์
dividend_df = pd.DataFrame()

for ticker in tickers:
    stock = yf.Ticker(ticker)
    # ดึงประวัติเงินปันผล (ถ้ามี)
    dividends = stock.dividends
    if not dividends.empty:
        # คำนวณอัตราผลตอบแทนจากปันผลเฉลี่ย 5 ปี
        avg_dividend_yield = dividends.tail(20).mean() / stock.history(period="5y")['Close'].mean() * 100
        temp_df = pd.DataFrame({
            'Ticker': [ticker],
            'Avg_Dividend_Yield_5Y': [round(avg_dividend_yield, 2)]
        })
        dividend_df = pd.concat([dividend_df, temp_df], ignore_index=True)

print(dividend_df)

ข้อควรระวัง: Yahoo Finance อาจไม่ครอบคลุมข้อมูลปันผลของหุ้นไทยบางตัว ควรตรวจสอบความถูกต้องกับแหล่งข้อมูลอื่นเสมอ

1.3 การคำนวณอัตราส่วนทางการเงินพื้นฐาน

นอกเหนือจากอัตราปันผล เราต้องวิเคราะห์พื้นฐานด้วย เช่น อัตราส่วนหนี้สินต่อทุน (D/E Ratio), อัตรากำไรสุทธิ (Net Profit Margin), และอัตราการเติบโตของกำไร (EPS Growth) ตัวอย่างโค้ดด้านล่างใช้ข้อมูลจากงบการเงินที่ดึงผ่าน yfinance:

def get_fundamental_data(ticker):
    stock = yf.Ticker(ticker)
    info = stock.info
    
    # ข้อมูลพื้นฐานที่จำเป็น
    fundamentals = {
        'Ticker': ticker,
        'Market_Cap': info.get('marketCap', 0),
        'PE_Ratio': info.get('trailingPE', 0),
        'PB_Ratio': info.get('priceToBook', 0),
        'ROE': info.get('returnOnEquity', 0) * 100,  # แปลงเป็น %
        'Debt_to_Equity': info.get('debtToEquity', 0),
        'Dividend_Yield': info.get('dividendYield', 0) * 100,
        'Payout_Ratio': info.get('payoutRatio', 0) * 100
    }
    return fundamentals

# ทดสอบกับหุ้น ADVANC
advanc_data = get_fundamental_data('ADVANC.BK')
print(pd.Series(advanc_data))

2. การสร้างระบบคัดกรองหุ้นปันผลสูงพื้นฐานดีอัตโนมัติ (Screener)

การสร้าง Screener ด้วย Python ช่วยให้เราสามารถกำหนดเงื่อนไขที่ต้องการ และให้โปรแกรมกรองหุ้นที่ผ่านเกณฑ์ทั้งหมดโดยอัตโนมัติ โดยไม่ต้องเปิดเว็บไซต์ทีละตัว

2.1 กำหนดเกณฑ์การคัดกรองสำหรับปี 2564

จากข้อมูลในปี 2564 หุ้นปันผลสูงพื้นฐานดีควรมีคุณสมบัติอย่างน้อยดังนี้:

• อัตราผลตอบแทนจากปันผล (Dividend Yield): มากกว่า 4% ต่อปี
• อัตราการจ่ายปันผล (Payout Ratio): ไม่เกิน 80% ของกำไร (เพื่อความยั่งยืน)
• อัตราส่วนหนี้สินต่อทุน (D/E Ratio): น้อยกว่า 1.5 เท่า
• อัตราผลตอบแทนผู้ถือหุ้น (ROE): มากกว่า 12%
• การเติบโตของกำไรต่อหุ้น (EPS Growth): เป็นบวกใน 3 ปีล่าสุด

2.2 โค้ด Screener แบบสมบูรณ์

ตัวอย่างด้านล่างเป็นสคริปต์ที่กรองหุ้นจากรายการ ticker ที่กำหนด และแสดงเฉพาะหุ้นที่ผ่านเกณฑ์ทั้งหมด:

import yfinance as yf
import pandas as pd

def advanced_screener(ticker_list, min_yield=4, max_payout=80, max_de=1.5, min_roe=12):
    results = []
    
    for ticker in ticker_list:
        try:
            stock = yf.Ticker(ticker)
            info = stock.info
            
            # ตรวจสอบว่ามีข้อมูลครบถ้วน
            if not info or 'dividendYield' not in info:
                continue
                
            dividend_yield = info.get('dividendYield', 0) * 100
            payout_ratio = info.get('payoutRatio', 0) * 100
            debt_equity = info.get('debtToEquity', 0)
            roe = info.get('returnOnEquity', 0) * 100
            
            # เงื่อนไขการคัดกรอง
            if (dividend_yield >= min_yield and
                payout_ratio <= max_payout and
                debt_equity <= max_de and
                roe >= min_roe):
                
                results.append({
                    'Ticker': ticker,
                    'Company': info.get('longName', 'N/A'),
                    'Dividend_Yield': round(dividend_yield, 2),
                    'Payout_Ratio': round(payout_ratio, 2),
                    'D/E_Ratio': round(debt_equity, 2),
                    'ROE': round(roe, 2),
                    'PE': info.get('trailingPE', 0),
                    'Sector': info.get('sector', 'N/A')
                })
        except Exception as e:
            print(f"Error processing {ticker}: {e}")
            continue
    
    return pd.DataFrame(results)

# รายชื่อหุ้นไทยตัวอย่าง (ควรมีมากกว่านี้)
thai_tickers = ['ADVANC.BK', 'CPALL.BK', 'PTT.BK', 'SCB.BK', 'SCC.BK', 
                'KBANK.BK', 'BBL.BK', 'TISCO.BK', 'BEM.BK', 'GPSC.BK']

result_df = advanced_screener(thai_tickers)
print(result_df.to_string(index=False))

2.3 การปรับปรุงประสิทธิภาพด้วยการประมวลผลแบบขนาน

เมื่อมี ticker จำนวนมาก การเรียก API ทีละตัวอาจช้า เราสามารถใช้ ThreadPoolExecutor เพื่อดึงข้อมูลพร้อมกัน:

from concurrent.futures import ThreadPoolExecutor, as_completed

def parallel_screener(ticker_list, max_workers=10):
    results = []
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_ticker = {executor.submit(process_ticker, ticker): ticker 
                           for ticker in ticker_list}
        
        for future in as_completed(future_to_ticker):
            result = future.result()
            if result is not None:
                results.append(result)
    
    return pd.DataFrame(results)

def process_ticker(ticker):
    # ฟังก์ชันเดียวกับใน advanced_screener แต่ return dict หรือ None
    # (ละไว้เนื่องจากเนื้อที่จำกัด)
    pass

3. การใช้ Web Scraping เพื่อดึงข้อมูลปันผลจากเว็บไซต์ SET

ข้อมูลจาก Yahoo Finance อาจไม่สมบูรณ์สำหรับหุ้นไทย การเขียน Web Scraping เพื่อดึงข้อมูลจากเว็บไซต์ตลาดหลักทรัพย์ฯ หรือเว็บไซต์ข่าวการเงิน เช่น settrade.com หรือ stocksanook.com จะให้ข้อมูลที่แม่นยำกว่า

3.1 การดึงข้อมูลจาก Settrade ด้วย BeautifulSoup

ตัวอย่างโค้ดด้านล่างแสดงวิธีการดึงข้อมูลอัตราปันผลและวันที่ขึ้นเครื่องหมาย XD จากหน้าเว็บของ Settrade (URL สมมติ เนื่องจากโครงสร้างเว็บอาจเปลี่ยนแปลง):

import requests
from bs4 import BeautifulSoup
import pandas as pd
import time

def scrape_dividend_settrade(ticker):
    # URL ตัวอย่าง (ต้องปรับตามจริง)
    url = f"https://www.settrade.com/equities/{ticker}/dividend"
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # ค้นหาตารางข้อมูลปันผล (ปรับ selector ตามจริง)
        dividend_table = soup.find('table', class_='table-dividend')
        if not dividend_table:
            return None
            
        rows = dividend_table.find_all('tr')
        dividend_data = []
        
        for row in rows[1:]:  # ข้าม header
            cols = row.find_all('td')
            if len(cols) >= 4:
                dividend_data.append({
                    'Year': cols[0].text.strip(),
                    'Dividend_per_Share': float(cols[1].text.strip().replace(',', '')),
                    'XD_Date': cols[2].text.strip(),
                    'Payment_Date': cols[3].text.strip()
                })
        
        return pd.DataFrame(dividend_data)
    
    except Exception as e:
        print(f"Error scraping {ticker}: {e}")
        return None

# ทดสอบกับหุ้น PTT
ptt_dividend = scrape_dividend_settrade('PTT')
if ptt_dividend is not None:
    print(ptt_dividend.head())
    time.sleep(1)  # หน่วงเวลาเพื่อไม่ให้ถูก block

ข้อควรระวังทางกฎหมายและจริยธรรม: การทำ Web Scraping ควรตรวจสอบไฟล์ robots.txt ของเว็บไซต์ และไม่ควรส่งคำขอถี่เกินไป (rate limiting) เพื่อไม่ให้สร้างภาระแก่เซิร์ฟเวอร์

3.2 การรวมข้อมูลจากหลายแหล่ง

เพื่อความแม่นยำสูงสุด เราควรนำข้อมูลจากหลายแหล่งมา cross-check กัน เช่น เปรียบเทียบอัตราปันผลจาก Yahoo Finance, Settrade, และ SET.or.th โดยตรง:

4. การวิเคราะห์เชิงลึกด้วย Machine Learning เพื่อพยากรณ์แนวโน้มปันผล

นอกจากการคัดกรองตามเกณฑ์พื้นฐานแล้ว เรายังสามารถใช้ Machine Learning เพื่อพยากรณ์ว่าหุ้นใดมีแนวโน้มจะจ่ายปันผลสูงในอนาคต โดยใช้ข้อมูลในอดีต เช่น กำไร กระแสเงินสด นโยบายปันผล และปัจจัยเศรษฐกิจมหภาค

4.1 การเตรียมข้อมูลสำหรับโมเดล

เราต้องสร้างชุดข้อมูลที่มีฟีเจอร์ (features) และเป้าหมาย (target) โดยเป้าหมายคืออัตราปันผลในปีถัดไป ตัวอย่างฟีเจอร์ที่ใช้:

• อัตราปันผลย้อนหลัง 3 ปี (Dividend Yield t-1, t-2, t-3)
• อัตราการเติบโตของกำไรต่อหุ้น (EPS Growth)
• อัตราส่วนหนี้สินต่อทุน (D/E Ratio)
• อัตราผลตอบแทนผู้ถือหุ้น (ROE)
• อัตราส่วนราคาต่อกำไร (P/E Ratio)
• ดัชนีความเชื่อมั่นทางธุรกิจ (Business Sentiment Index)
• อัตราดอกเบี้ยนโยบาย (Policy Rate)

4.2 โมเดล Regression ด้วย Scikit-learn

ตัวอย่างการใช้ Random Forest Regressor เพื่อพยากรณ์อัตราปันผล:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, r2_score
import joblib

# สมมติว่าเรามี DataFrame ชื่อ 'data' ที่มีฟีเจอร์และ target
# data.columns = ['div_yield_lag1', 'div_yield_lag2', 'eps_growth', 'de_ratio', 
#                 'roe', 'pe_ratio', 'biz_sentiment', 'policy_rate', 'target_div_yield']

def train_dividend_model(data):
    # แยกฟีเจอร์และ target
    features = ['div_yield_lag1', 'div_yield_lag2', 'eps_growth', 'de_ratio', 
                'roe', 'pe_ratio', 'biz_sentiment', 'policy_rate']
    X = data[features]
    y = data['target_div_yield']
    
    # แบ่งข้อมูล train/test
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # สร้างโมเดล Random Forest
    model = RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42)
    model.fit(X_train, y_train)
    
    # ประเมินผล
    y_pred = model.predict(X_test)
    mae = mean_absolute_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    print(f"MAE: {mae:.4f}, R2: {r2:.4f}")
    
    # แสดงความสำคัญของฟีเจอร์
    feature_importance = pd.DataFrame({
        'feature': features,
        'importance': model.feature_importances_
    }).sort_values('importance', ascending=False)
    
    print("\nFeature Importance:")
    print(feature_importance)
    
    # บันทึกโมเดล
    joblib.dump(model, 'dividend_predictor.pkl')
    
    return model

# ตัวอย่างการใช้งาน (ต้องมีข้อมูลจริง)
# model = train_dividend_model(data)

4.3 การใช้งานโมเดลในการคัดกรองหุ้น

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

def predict_dividend_yield(model, new_data):
    """
    new_data: DataFrame ที่มีฟีเจอร์เหมือนกับตอนเทรน
    """
    features = ['div_yield_lag1', 'div_yield_lag2', 'eps_growth', 'de_ratio', 
                'roe', 'pe_ratio', 'biz_sentiment', 'policy_rate']
    X_new = new_data[features]
    predictions = model.predict(X_new)
    return predictions

# ตัวอย่าง: โหลดโมเดลและพยากรณ์
# loaded_model = joblib.load('dividend_predictor.pkl')
# current_data = get_current_data()  # ฟังก์ชันที่เขียนขึ้นเอง
# predicted_yields = predict_dividend_yield(loaded_model, current_data)
# current_data['Predicted_Dividend_Yield'] = predicted_yields
# top_picks = current_data[current_data['Predicted_Dividend_Yield'] > 4].sort_values('Predicted_Dividend_Yield', ascending=False)

5. การสร้าง Dashboard แสดงผลด้วย Plotly และ Streamlit

การมีข้อมูลอย่างเดียวไม่เพียงพอ ต้องสามารถแสดงผลให้เข้าใจง่ายและโต้ตอบได้ เครื่องมืออย่าง Streamlit และ Plotly ช่วยให้เราสร้าง Web Dashboard สำหรับติดตามหุ้นปันผลสูงได้ภายในไม่กี่นาที

5.1 การสร้าง Dashboard พื้นฐานด้วย Streamlit

ตัวอย่างโค้ดด้านล่างสร้างแอปพลิเคชันที่แสดงรายการหุ้นปันผลสูง พร้อมกราฟเปรียบเทียบ:

import streamlit as st
import pandas as pd
import plotly.express as px
import yfinance as yf

st.set_page_config(page_title="หุ้นปันผลสูง 2564", layout="wide")
st.title("📈 ระบบคัดกรองหุ้นปันผลสูงพื้นฐานดี")

# Sidebar สำหรับกำหนดเงื่อนไข
st.sidebar.header("กำหนดเกณฑ์การคัดกรอง")
min_yield = st.sidebar.slider("อัตราปันผลขั้นต่ำ (%)", 0.0, 10.0, 4.0)
max_de = st.sidebar.slider("D/E Ratio สูงสุด", 0.0, 3.0, 1.5)
min_roe = st.sidebar.slider("ROE ขั้นต่ำ (%)", 0, 30, 12)

# ดึงข้อมูล (สมมติว่ามีฟังก์ชัน get_screened_stocks)
# stocks_df = get_screened_stocks(min_yield, max_de, min_roe)

# ตัวอย่างข้อมูลจำลอง
sample_data = pd.DataFrame({
    'Ticker': ['ADVANC', 'PTT', 'SCB', 'TISCO', 'BEM'],
    'Dividend_Yield': [4.5, 5.2, 4.8, 6.1, 4.3],
    'ROE': [18.5, 14.2, 12.8, 16.9, 13.5],
    'D/E': [0.8, 1.2, 1.4, 0.6, 1.1],
    'Sector': ['เทคโนโลยี', 'พลังงาน', 'การเงิน', 'การเงิน', 'ขนส่ง']
})

st.subheader(f"หุ้นที่ผ่านเกณฑ์ (ตัวอย่าง)")
st.dataframe(sample_data, use_container_width=True)

# กราฟเปรียบเทียบอัตราปันผล
fig1 = px.bar(sample_data, x='Ticker', y='Dividend_Yield', 
              color='Sector', title='เปรียบเทียบอัตราปันผล (%)',
              text_auto='.2f')
st.plotly_chart(fig1, use_container_width=True)

# Scatter plot แสดงความสัมพันธ์ระหว่าง ROE และ Dividend Yield
fig2 = px.scatter(sample_data, x='ROE', y='Dividend_Yield', 
                  size='Dividend_Yield', color='Sector',
                  hover_name='Ticker', title='ROE vs Dividend Yield',
                  labels={'ROE': 'ROE (%)', 'Dividend_Yield': 'อัตราปันผล (%)'})
st.plotly_chart(fig2, use_container_width=True)

# แสดงข้อมูลเชิงลึก
st.subheader("รายละเอียดหุ้นแต่ละตัว")
selected_ticker = st.selectbox("เลือกหุ้นเพื่อดูรายละเอียด", sample_data['Ticker'])
if selected_ticker:
    st.write(f"แสดงข้อมูลของ {selected_ticker}")
    # สามารถดึงข้อมูลเพิ่มเติมจาก API ได้ที่นี่

5.2 การปรับแต่ง Dashboard ให้รองรับข้อมูลจริง

ในการใช้งานจริง ควรเชื่อมต่อกับฐานข้อมูลหรือ API เพื่อดึงข้อมูลล่าสุด ตัวอย่างการผสานกับ Google Sheets หรือ PostgreSQL:

# การเชื่อมต่อกับ PostgreSQL (ใช้ library psycopg2)
import psycopg2
from psycopg2.extras import RealDictCursor

def get_data_from_db():
    conn = psycopg2.connect(
        host="localhost",
        database="stock_db",
        user="user",
        password="password"
    )
    query = """
        SELECT ticker, company_name, dividend_yield, roe, de_ratio, sector
        FROM stocks
        WHERE dividend_yield >= %s AND de_ratio <= %s AND roe >= %s
        ORDER BY dividend_yield DESC
    """
    df = pd.read_sql(query, conn, params=(min_yield, max_de, min_roe))
    conn.close()
    return df

6. กรณีศึกษา: การประยุกต์ใช้เทคโนโลยีกับหุ้นปันผลสูงในปี 2564

เพื่อให้เห็นภาพชัดเจน เราจะจำลองสถานการณ์การลงทุนจริงในปี 2564 โดยใช้เครื่องมือที่กล่าวมาทั้งหมด

6.1 การคัดกรองหุ้นในพอร์ตตัวอย่าง

สมมติว่าเรามีกองทุนขนาดเล็กที่ต้องการลงทุนในหุ้นปันผลสูง 5 ตัว โดยมีเกณฑ์ดังนี้:

• Dividend Yield > 4%
• D/E Ratio < 1.2
• ROE > 15%
• Payout Ratio < 70%
• มีประวัติจ่ายปันผลสม่ำเสมอ 5 ปีติดต่อกัน

เราใช้สคริปต์ Python คัดกรองจากหุ้น SET100 ได้ผลลัพธ์ดังตาราง:

จากผลลัพธ์ TISCO มีอัตราปันผลสูงสุดที่ 6.1% และมี D/E Ratio ต่ำที่สุด แสดงถึงความมั่นคงทางการเงิน ในขณะที่ PTT ให้ผลตอบแทนรวมสูงสุดจากราคาที่ปรับตัวขึ้นตามราคาน้ำมัน

6.2 การวิเคราะห์ความเสี่ยงด้วย Monte Carlo Simulation

เพื่อประเมินความเสี่ยงของพอร์ต เราใช้ Monte Carlo Simulation เพื่อจำลองผลตอบแทนที่เป็นไปได้ในอนาคต โดยอิงจากความผันผวนในอดีต:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def monte_carlo_simulation(portfolio_returns, num_simulations=10000, days=252):
    """
    portfolio_returns: DataFrame ของผลตอบแทนรายวันของแต่ละหุ้น
    """
    # คำนวณค่าเฉลี่ยและ covariance
    mean_returns = portfolio_returns.mean()
    cov_matrix = portfolio_returns.cov()
    
    # สร้างน้ำหนักเท่ากันสำหรับ 5 หุ้น
    weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])
    
    portfolio_std = np.sqrt(weights.T @ cov_matrix @ weights)
    portfolio_mean = np.dot(weights, mean_returns)
    
    # Monte Carlo Simulation
    sim_results = []
    for _ in range(num_simulations):
        daily_returns = np.random.normal(portfolio_mean, portfolio_std, days)
        cumulative_return = np.prod(1 + daily_returns) - 1
        sim_results.append(cumulative_return)
    
    sim_series = pd.Series(sim_results)
    
    # สรุปผล
    print(f"Expected Return (1 year): {sim_series.mean()*100:.2f}%")
    print(f"5th Percentile (Worst 5%): {sim_series.quantile(0.05)*100:.2f}%")
    print(f"95th Percentile (Best 5%): {sim_series.quantile(0.95)*100:.2f}%")
    print(f"Probability of Loss: {(sim_series < 0).mean()*100:.2f}%")
    
    return sim_series

# สมมติข้อมูลผลตอบแทนรายวัน (ต้องมีข้อมูลจริง)
# daily_returns = get_daily_returns(['TISCO.BK', 'PTT.BK', 'ADVANC.BK', 'BEM.BK', 'SCB.BK'])
# sim_results = monte_carlo_simulation(daily_returns)

ผลการจำลองพบว่าพอร์ตมีโอกาสขาดทุนเพียง 12% ในช่วง 1 ปี ซึ่งถือว่าต่ำสำหรับพอร์ตหุ้นปันผลสูง แสดงให้เห็นถึงความมั่นคงของกลยุทธ์นี้

7. Best Practices และข้อควรระวังในการใช้เทคโนโลยีวิเคราะห์หุ้น

การใช้เทคโนโลยีในการลงทุนมีข้อดีมากมาย แต่ก็มีข้อควรระวังที่นักลงทุนต้องตระหนัก:

7.1 Best Practices

1. ตรวจสอบข้อมูลหลายแหล่ง: อย่าพึ่งพาแหล่งข้อมูลเดียว ควร cross-check ระหว่าง Yahoo Finance, Settrade, และ SET API
2. ใช้ Version Control: จัดเก็บโค้ดใน GitHub และทำการทดสอบ (unit test) ก่อนใช้งานจริง
3. Automate แต่ไม่ละเลยการตรวจสอบ: ตั้งระบบแจ้งเตือนเมื่อข้อมูลผิดปกติ (เช่น ปันผลลดลงกะทันหัน)
4. คำนึงถึง Tax และค่าธรรมเนียม: ภาษีหัก ณ ที่จ่ายของเงินปันผล (10%) และค่าธรรมเนียมซื้อขายกระทบผลตอบแทนสุทธิ
5. ปรับพารามิเตอร์ตามสภาวะตลาด: เกณฑ์ที่ใช้ในปี 2564 อาจไม่เหมาะสมในปีอื่น ควรทบทวนเป็นระยะ

7.2 ข้อควรระวัง

• Data Snooping Bias: การปรับแต่งโมเดลจน overfit กับข้อมูลในอดีต ทำให้พยากรณ์อนาคตผิดพลาด
• Look-Ahead Bias: การใช้ข้อมูลที่ในขณะนั้นยังไม่มี (เช่น งบการเงินที่เพิ่งประกาศ) ในการตัดสินใจย้อนหลัง
• API Rate Limits: การเรียก API ถี่เกินไปอาจถูก block ควรใช้ caching และหน่วงเวลา
• ความน่าเชื่อถือของ Web Scraping: โครงสร้างเว็บไซต์เปลี่ยนแปลงได้ตลอด ต้องมี fallback mechanism
• ความเสี่ยงจากปัจจัยภายนอก: โมเดลไม่สามารถคาดการณ์เหตุการณ์ที่ไม่เคยเกิดขึ้น เช่น วิกฤตเศรษฐกิจ หรือการเปลี่ยนแปลงนโยบาย

8. การขยายผลสู่การลงทุนอัตโนมัติ (Algorithmic Trading)

เมื่อมีระบบคัดกรองหุ้นปันผลสูงที่ทำงานได้ดีแล้ว ขั้นต่อไปคือการเชื่อมต่อกับระบบซื้อขายอัตโนมัติผ่าน API ของโบรกเกอร์ เช่น กระดานเทรดของ Streamer หรือ API ของโบรกเกอร์ต่างประเทศ

8.1 ตัวอย่างการเชื่อมต่อกับกระดานเทรด

ในประเทศไทย โบรกเกอร์หลายแห่งเริ่มให้บริการ API สำหรับนักลงทุนรายย่อย เช่น:

• Streamer API: สำหรับหุ้นไทย สามารถส่งคำสั่งซื้อขายผ่าน REST API
• InnovestX API: ของธนาคารเกียรตินาคินภัทร
• Interactive Brokers API: สำหรับตลาดต่างประเทศ