Kode Python SVM Untuk Data Saham

Deskripsi Singkat Kode Python SVM Saham

Script ini dirancang untuk mendemonstrasikan secara langsung teori Kernel Trick yang telah kita bahas sebelumnya:

1. Generasi Data Saham Simulasi Non-Linear: Kode ini menghasilkan dataset saham buatan dengan fitur P/E Ratio, Volatilitas, dan Volume Ratio. Keputusan “Beli” (1) didefinisikan secara non-linear (berada pada rentang nilai P/E dan Volatilitas tertentu di tengah koordinat), sedangkan “Jual” (0) berada di sekelilingnya. Kami juga menambahkan 5% acakan (noise) untuk mensimulasikan ketidakpastian pasar riil.
2. Standardisasi Fitur (StandardScaler): Dikarenakan SVM sangat sensitif terhadap skala data, kode ini menerapkan standardisasi untuk memastikan semua fitur memiliki rata-rata 0 dan varians 1 sehingga perhitungan jarak geometris bekerja dengan adil.
3. Perbandingan Dua Kernel SVM:
   • Linear SVM: Model mencoba memisahkan data menggunakan garis/hyperplane lurus biasa di ruang dimensi asli.
   • RBF SVM (Radial Basis Function): Model menggunakan fungsi kernel non-linear untuk memetakan data secara implisit ke dimensi tinggi agar dapat dipisahkan secara linear dengan akurat.
4. Evaluasi Model: Menghasilkan metrik akurasi (accuracy score), tabel ketepatan (confusion matrix), serta metrik presisi (precision) dan sensitivitas (recall) untuk masing-masing keputusan

Hasil Eksekusi Kode Simulasi

Ketika kode ini dijalankan di sistem, berikut adalah ringkasan hasil performa yang didapatkan:

• Akurasi SVM Linear: 85.20%
• Akurasi SVM RBF (Non-Linear): 93.60%

Hasil ini membuktikan secara empiris bahwa ketika data pasar saham memiliki karakteristik yang melengkung dan kompleks (non-linear), SVM RBF jauh lebih unggul dibandingkan model linear tradisional karena kemampuan “sihir” pemetaan dimensinya

Tampilan Kode

Berikut adalah cuplikan blok kode utama proses pemisahan data, standardisasi, serta pelatihan model menggunakan pustaka scikit-learn:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

def generate_mock_stock_data(n_samples=1000, random_seed=42):
    """
    Menghasilkan data saham simulasi non-linear untuk keperluan demonstrasi SVM.
    Fitur:
    - PE_Ratio: Rasio Price-to-Earnings
    - Volatilitas: Volatilitas harga historis (standar deviasi return)
    - Volume_Ratio: Rasio volume perdagangan saat ini terhadap rata-ratanya
    """
    np.random.seed(random_seed)
    
    # 1. Generate fitur acak
    pe_ratio = np.random.uniform(5, 35, n_samples)
    volatilitas = np.random.uniform(0.1, 0.8, n_samples)
    volume_ratio = np.random.uniform(0.5, 2.5, n_samples)
    
    # Buat DataFrame
    df = pd.DataFrame({
        'PE_Ratio': pe_ratio,
        'Volatilitas': volatilitas,
        'Volume_Ratio': volume_ratio
    })
    
    # 2. Buat target keputusan non-linear (Beli = 1, Jual = 0)
    # Katakanlah kondisi ideal untuk "Beli" adalah PE_Ratio wajar (12 - 22) DAN volatilitas sedang (0.2 - 0.5)
    # Ini membentuk pola melingkar/non-linear di ruang fitur.
    condition_buy = (
        (df['PE_Ratio'] >= 12) & (df['PE_Ratio'] <= 22) & 
        (df['Volatilitas'] >= 0.2) & (df['Volatilitas'] <= 0.5)
    )
    
    df['Keputusan'] = np.where(condition_buy, 1, 0)
    
    # Tambahkan sedikit noise (kebisingan/kesalahan riil pasar) sebesar 5%
    noise_mask = np.random.rand(n_samples) < 0.05
    df.loc[noise_mask, 'Keputusan'] = 1 - df.loc[noise_mask, 'Keputusan']
    
    return df

def main():
    print("=== Memulai Simulasi Analisis Saham Menggunakan SVM ===")
    
    # 1. Mempersiapkan Data Saham Simulasi
    df = generate_mock_stock_data(n_samples=1000)
    print(f"Data berhasil digenerasi dengan {len(df)} sampel.")
    print("Distribusi Kelas Keputusan:")
    print(df['Keputusan'].value_counts().rename({1: 'BELI (1)', 0: 'JUAL (0)'}))
    print("\nContoh data awal:")
    print(df.head())
    
    # Split fitur dan target
    X = df[['PE_Ratio', 'Volatilitas', 'Volume_Ratio']]
    y = df['Keputusan']
    
    # 2. Membagi Data menjadi Train & Test Set
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
    
    # 3. Standardisasi Fitur (Sangat penting untuk SVM agar jarak fitur seimbang)
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)
    
    # 4. Melatih SVM dengan Kernel Linear (Sebagai Pembanding)
    print("\n--- Melatih Linear SVM ---")
    linear_svm = SVC(kernel='linear', C=1.0, random_state=42)
    linear_svm.fit(X_train_scaled, y_train)
    y_pred_linear = linear_svm.predict(X_test_scaled)
    acc_linear = accuracy_score(y_test, y_pred_linear)
    print(f"Akurasi SVM Linear: {acc_linear * 100:.2f}%")
    
    # 5. Melatih SVM dengan Kernel RBF (Radial Basis Function - Untuk Data Non-Linear)
    print("\n--- Melatih RBF SVM (Kernel Non-Linear) ---")
    rbf_svm = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
    rbf_svm.fit(X_train_scaled, y_train)
    y_pred_rbf = rbf_svm.predict(X_test_scaled)
    acc_rbf = accuracy_score(y_test, y_pred_rbf)
    print(f"Akurasi SVM RBF: {acc_rbf * 100:.2f}%")
    
    # 6. Evaluasi Detail untuk SVM RBF
    print("\nLaporan Klasifikasi Detail untuk SVM RBF:")
    print(classification_report(y_test, y_pred_rbf, target_names=['JUAL', 'BELI']))
    
    print("Confusion Matrix untuk SVM RBF:")
    cm = confusion_matrix(y_test, y_pred_rbf)
    print(f"True Negative (Benar Jual): {cm[0, 0]}")
    print(f"False Positive (Salah Beli): {cm[0, 1]}")
    print(f"False Negative (Salah Jual): {cm[1, 0]}")
    print(f"True Positive (Benar Beli): {cm[1, 1]}")
    
if __name__ == "__main__":
    main()