Python VS Go バックテスト性能比較

今回は、手元の解析環境(Core i5-8500 @ 3.00GHz / 6コア6スレッド / RAM 32GB / M.2 SSD 1TB)を使って、Python と Go(Golang) のどちらでバックテストを回すべきか、実測ベンチマークをもとに整理した備忘録です。

第8世代CPUの中古PCにメモリ増設とM.2 SSD換装を加えた、お小遣いレベルで作れる庶民環境です。

「Pythonは基本シングルスレッド、Goは6コアを使って1レコードずつループ処理する」という大枠のイメージから一歩踏み込み、実際の3,404万行ティックデータ(tick_master.npy → tick_master_col4.bin)で速度差を数値化しました。

1. まず押さえておきたい仕組みの整理

  • Goは「自動的に6コア全部を使う」わけではない:通常の for ループを書いただけでは1コア(1ゴルーチン)で動きます。6コアを活かすには、ゴルーチン(go func())で処理を分割する設計が必要です。
  • Pythonは「配列・列演算」が得意、1行ループは苦手:NumPyやPolarsなどの内部処理は高速ですが、建玉・SL/TP・スプレッドなどの状態を1ティックずつ更新するループはPythonの純粋な for だと重くなります。
  • .npy を生の .bin(int32)にすると相性抜群:既存のNumPy配列を連続メモリで .bin 書き出ししておくと、Go側でパースの手間なく一気に読み込め、RAM 32GB+M.2 SSDの恩恵を最大限に受けられます。

2. ベンチマーク実測結果(34,045,105行 × 10回)

tick_master.npy(形状 (34045106, 16)・int32)から対象列を切り出し、tick_master_col4.bin(129.9MB)を生成(読み込み&書き出しは 0.158秒)。同一条件のティック状態遷移ループを10回連続実行した実測値は以下の通りです。

実行方式1回あたり平均10回合計(約3.4億行)対Pythonループ倍率100条件回した場合の目安
Python(生 for ループ)約 21.63 秒約 216.35 秒(約3分36秒)基準(1倍)約 36.1 分
Go(1コア / 単一ゴルーチン)約 57.45 ms(0.0575秒)約 574.54 ms(0.575秒)約 377 倍約 5.7 秒
Go(6コア / 6ゴルーチン並列)約 11.47 ms(0.0115秒)約 114.68 ms(0.115秒)約 1,887 倍約 1.15 秒

実測メモ:Go 1コアは trades=291044, pnl_pts=-649742 でPythonと完全一致。Go 6コアは trades=291049, pnl_pts=-649772 とわずかに差が出ましたが、これは6分割したチャンク境界(5箇所)で建玉保有中の状態がリセットされたためです。

3. Python と Go の現実的な使い分け

  • ざっくり傾向を見る・前処理・可視化 → Python:仮説出し、データ整形、指標・集計、グラフ描画など「試行錯誤の速さ」や「表現力」が活きる工程はPythonが快適です。
  • パラメータを大量に試す・重い1行ループ → Go:グリッド/ランダム探索や、約定・建玉管理を伴う数千万〜数億行ループはGoのコンパイル済みバイナリ+6コア並列が圧倒的です。
  • 注意点(カーブフィッティング):探索が速くなるほど大量に試せてしまいますが、最適値周辺でパラメータをズラしても成績が崩れないか、別期間でも傾向が再現するかの確認は忘れずに行います。

4. 今回使ったベンチマークコード(記録用)

Python側(.npy → .bin 出力 + 10回ループ計測)

import time
import numpy as np

NPY_PATH = "tick_master.npy"
BIN_PATH = "tick_master_col4.bin"
BID_COL = 4
START_ROW = 1
RUNS = 10

t_load0 = time.perf_counter()
arr = np.load(NPY_PATH, mmap_mode="r")
bid = np.ascontiguousarray(arr[START_ROW:, BID_COL], dtype=np.int32)
t_load1 = time.perf_counter()

//Go用の.binファイルを生成
np.ascontiguousarray(bid, dtype=np.int32).tofile(BIN_PATH)
n_rows = len(bid)
print(f"Loaded & sliced rows={n_rows:,} in {t_load1 - t_load0:.3f}s | Exported {BIN_PATH} ({bid.nbytes / (1024**2):.1f} MB)\n")

//ベンチマーク開始
entry_thresh = 4
sl = 15
tp = 25
spread = 3
sentinel = -2147483648

times = []
for r in range(1, RUNS + 1):
    t0 = time.perf_counter()
    pos = 0
    entry = 0
    pnl_sum = 0
    trades = 0

    for i in range(1, n_rows):
        p = int(bid[i])
        prev = int(bid[i - 1])
        if p == sentinel or prev == sentinel:
            continue

        if pos == 0:
            if p > prev + entry_thresh:
                pos = 1
                entry = p + spread
                trades += 1
        else:
            diff = p - entry
            if diff <= -sl or diff >= tp:
                pnl_sum += diff
                pos = 0

    dt = time.perf_counter() - t0
    times.append(dt)
    print(f"[Python Loop] Run {r:02d}: {dt:.4f}s | trades={trades} | pnl_pts={pnl_sum}")

print(f"\n[Python Loop] Avg ({RUNS} runs, {n_rows:,} rows/run): {sum(times)/len(times):.4f}s | Total: {sum(times):.4f}s")

Go側(.bin 読み込み + 1コア / 6コア並列で10回計測)

package main

import (
	"encoding/binary"
	"fmt"
	"os"
	"sync"
	"time"
)

func loadInt32Bin(path string) ([]int32, error) {
	raw, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	count := len(raw) / 4
	out := make([]int32, count)
	for i := 0; i < count; i++ {
		out[i] = int32(binary.LittleEndian.Uint32(raw[i*4 : (i+1)*4]))
	}
	return out, nil
}

func runChunk(bid []int32, entryThresh, sl, tp, spread int32) (int, int64) {
	const sentinel int32 = -2147483648
	pos := 0
	var entry int32 = 0
	trades := 0
	var pnlSum int64 = 0

	for i := 1; i < len(bid); i++ {
		p := bid[i]
		prev := bid[i-1]
		if p == sentinel || prev == sentinel {
			continue
		}

		if pos == 0 {
			if p > prev+entryThresh {
				pos = 1
				entry = p + spread
				trades++
			}
		} else {
			diff := int64(p) - int64(entry)
			if diff <= int64(-sl) || diff >= int64(tp) {
				pnlSum += diff
				pos = 0
			}
		}
	}
	return trades, pnlSum
}

func main() {
	const binPath = "tick_master_col4.bin"
	const runs = 10
	const entryThresh int32 = 4
	const sl int32 = 15
	const tp int32 = 25
	const spread int32 = 3

	tLoad := time.Now()
	bid, err := loadInt32Bin(binPath)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Loaded %d int32 rows in %v\n\n", len(bid), time.Since(tLoad))

	var sum1 time.Duration
	for r := 1; r <= runs; r++ {
		t0 := time.Now()
		tr, pnl := runChunk(bid, entryThresh, sl, tp, spread)
		dt := time.Since(t0)
		sum1 += dt
		fmt.Printf("[Go 1-Core] Run %02d: %v | trades=%d | pnl_pts=%d\n", r, dt, tr, pnl)
	}
	fmt.Printf("[Go 1-Core] Avg (%d runs): %v | Total: %v\n\n", runs, sum1/runs, sum1)

	const workers = 6
	var sum6 time.Duration
	chunkSize := len(bid) / workers

	for r := 1; r <= runs; r++ {
		t0 := time.Now()
		var wg sync.WaitGroup
		trArr := make([]int, workers)
		pnlArr := make([]int64, workers)

		for w := 0; w < workers; w++ {
			start := w * chunkSize
			end := start + chunkSize
			if w == workers-1 {
				end = len(bid)
			}
			wg.Add(1)
			go func(idx, s, e int) {
				defer wg.Done()
				trArr[idx], pnlArr[idx] = runChunk(bid[s:e], entryThresh, sl, tp, spread)
			}(w, start, end)
		}
		wg.Wait()

		totalTr := 0
		var totalPnl int64 = 0
		for w := 0; w < workers; w++ {
			totalTr += trArr[w]
			totalPnl += pnlArr[w]
		}
		dt := time.Since(t0)
		sum6 += dt
		fmt.Printf("[Go 6-Core] Run %02d: %v | trades=%d | pnl_pts=%d\n", r, dt, totalTr, totalPnl)
	}
	fmt.Printf("[Go 6-Core] Avg (%d runs): %v | Total: %v\n", runs, sum6/runs, sum6)
}

タイトルとURLをコピーしました