用Numpy做一個自己的股票分析系統

HST-PF

凹賴

自我介紹
基礎知識
開始分析
建構系統

自我介紹

我是誰？

HST core member
小小工程師
宅心人厚的陽宅
史萊哲林信徒

mail:pf@hst.tw

為什麼會想研究股票？

身為一個小小上班族

每天領著微薄的薪水

你知道工程師窮到

連土都吃不起嗎？

沒有，因為你只想到

你自己

身為一個專業魯蛇

還是想要成為

傳說中的高富帥

但是在鬼島惡劣的環境下

想要突破魯蛇進入上流社會

似乎是個遙不可及的夢

在無法提高年薪的窘境下，只好想尋找其他收入了！！

為什麼想來Pycon分享？

基礎知識

賽局理論
古諾競爭
奧肯法則
凱恩斯利律效應
李嘉圖等價
菲利普斯曲線
瓦爾拉斯定律

這些今天通通不會講

真.基礎知識

投資與投機
股票與期貨
技術分析

傳說中，斯斯有兩種

?

理財也分兩種

投資

投機

投資

投機

時間

分析

風險

投資

投機

時間

分析

風險

降息啦！！

投資

投機

時間

分析

風險

投資

時間

分析

風險

投機

時間

分析

風險

投機

投資

時間

分析

風險

投機

投資

股票與期貨

股票 (Stock)

有價證卷
公司資本部份所有權的憑證
可以獲得股息和股利

但如果股票沒價了呢

期貨 (Futures)

一種投資衍生工具
商品期與金融期
可輕易的多和空
可看成槓桿較高的股票

股票市場如何賺錢？

想像成一個政府開的賭場

政府

散戶

大戶

散戶

只要猜對大小就可以賺到錢

但是如果你真的把他當賭博

那我們這些宅宅程式猿要怎麼在股海中賺到錢

技術分析

使用過去資訊推測未來趨勢
只考慮價格行為
建立在「歷史會不斷重演」

常見技術分析

K線
移動平均線
隨機指數
道式理論
波浪理論
.......

有這麼多方法要用那個呢？

讓我們聽聽專家的意見

名嘴1:這裡我們可以

看到趨勢上升，宜做多

名嘴2:這裡進入箱型整理, 建議觀望

名嘴3:這裡並無突破季線, 是假回檔, 宜做空

宅宅:X!都給你說就好了阿

開始分析

愛因斯坦：上帝不擲骰子

分析前有一件非常重要的事

你沒資料分析個0

那資料要去那裡抓呢？

想要嗎？我都放在那裡了

不過爬蟲不在這次範圍

大家就自求多福

如果你有幸把資料抓下來了

我們就來看看那些資訊很重要

重要資訊

時間
開盤價 (Open)
收盤價 (Close)
最高價 (High)
最低價 (Low)
成交量 (Volume)

掌握好資料後就

可以開始分析啦！

移動平均線 (MA)

P1 + P2 +...+ Pn

+ ....

Px ：第x天的價格

n ：n日

移動平均線 (MA)

def getMA(ori, n):
    MA = []
    MA.append(sum([ori[i] for i in range(n)]))

    for i in range(1, len(ori)-n):
        MA.append(MA[-1] - ori[i-1] + ori[i+n])

    for i in range(len(ori)):
        MA[i] /= n

    return MA

股票交易只有三種情形

買進

賣出

不動

買進

賣出

不動

-1

判斷買賣點

def judge(ori, MA):
    state = []
    for i in range(len(ori)):
        if ori[i] > MA[i]:
            state.append(-1)
        elif ori[i] < MA[i]:
            state.append(1)
        else:
            state.append(0)

    return state

計算收益

def calculateEarning(ori, state):
    earning = 0
    price = 0

    if state[0] != 0:
        price = ori[0]

    for i in range(1, len(ori)):
        if state[i-1] != state[i]:
            if state[i-1] == 1:
                earning += ori[i] - price
            elif state[i-1] == -1:
                earning -= ori[i] - proce

            price = ori[i]

    return earning

隨機指標 (KD)

RSV

Cn - Ln

Hn - Ln

：自定義參數

100%

⍺

RSVn

(1 -

⍺

)

Kn-1

⍺

(1 -

⍺

)

Dn-1

⍺

Cn：第n日收盤價

Hn：n日內最高價

Ln：n日內最低價

隨機指標 (KD)

def RSV(ori, i, n):
    ln = min(ori[i-n:i])
    hn = max(ori[i-n:i])
    return  ( ori[i] - ln ) / ( hn - ln )

def K(i):
    return alpha * rsv + (1-alpha) * K(i-1)

def D(i):
    return alpha * K(i) + (1-alpha) * D(i-1)

判斷買賣點

def judge(K, D):
    state = []
    
    for i in range(len(K))
        if K[i] > D[i]:
            state.append(1)
        elif K[i] < D[i]:
            state.append(-1)
        else:
            state.append(0)

    return state

那我是要看30日線

還是60日線？

KD值要高於80還是

70才算超買？

⍺值要設定1/3還是1/2?

雖然我們無法求得最佳解

但是我們能求近似解

代入參數

判斷多空

計算利潤

Itertools

import itertools as it

it.cycle([1,2,3])  -> 1,2,3,1,2,3,1....

it.product([1,2,3], repeat=2) 
    -> (1, 1), (1, 2), (1, 3), (2, 1), 
        (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)

it.permutations([1,2,3], 2) 
    -> (1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)

it.combinations([1,2,3], 2) 
    -> (1, 2), (1, 3), (2, 3)

it.combinations_with_replacement([1,2,3], 2) 
    -> (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)

那麼我們就來把

所有參數跑跑看吧

以均線為例

2-365日線 * 超過點數(0-200) * 3000隻股票

2-365日線 * 2-365日線 * 3000隻股票

3000隻股票 * 3000隻股票 * 3000隻股票

.........

不過天無絕人之路

我們還有兩條路可走

一、加快速度

前面屁鋪陳了這麼久

總算要步入今天的主題

Numpy

一個Python擴充庫
高速矩陣運算
大量數學函式
快！非常快！

import numpy as np
import random, time

future1 = []
future2 = []

for i in range(10000):
    future1.append(random.randint(1,10000))
    future2.append(random.randint(1,10000))

np_future1 = np.array(future1, dtype=int)
np_future2 = np.array(future2, dtype=int)

s1 = time.time()
for i in range(10000):
    a = future1[i] - future2[i]
e1 = time.time()

print 'Python : %.10fs' % (e1 - s1)

s2 = time.time()
b = np_future1 - np_future2
e2 = time.time()

print 'Numpy : %.10fs' % (e2 - s2)

Python : 0.0021190643s
Numpy  : 0.0000231266s

Numpy基礎

Numpy宣告矩陣

import numpy as np

a = np.array(list, dtype=[bool, int, float])

b = np.arange(num)

c = np.zeros(num)

d = np.ones(num)

Numpy矩陣運算

a = np.array([1,2,3,4,5], dtype=int)

a + 2 = [3,4,5,6,7]

a - 2 = [-1,0,1,2,3]

a * 2 = [2,4,6,8,10]

a / 2 = [0,1,1,2,2]

Numpy矩陣運算

a = np.array([1,2,3,4,5],  dtype=int)
b = np.array([6,7,8,9,10], dtype=int)

a + b = [7,9,11,13,15]

a - b = [-5,-5,-5,-5,-5]

a * b = [6,14,24,36,50]

a / b = [0,0,0,0,0]

Numpy條件選擇

a = np.array([1,2,3,4,5], dtype=int)

a[1:3] = [2,3]

a[a>3] = [4,5]

b = np.where(a>3) = [3,4]

np.take(a, b) = [4,5]

np.piecewise(a, [a<=2, a>=3], [-1,1]) = [-1,-1,1,1,1]

np.max(a) = 5

np.min(a) = 1

Numpy均線

futures = np.array(fututres_list, dtype=int)

weight = np.ones(num) / num

MA = np.convolve(weight, futures)[num-1:-num+1]

Numpy均線收益

state = MA1 - MA2

state = np.piecewise(state, [state<0, state>0], [-1,1])

judge(ori, state)

那還有沒有可以

跑更快的辦法呢？

Core

用

記住千萬不要multithread

multiprocess

import multiprocess as mul

queue = mul.Queue()

pool = mul.Pool(process=cpu_num)

while not queue.empty():
    args = queue.get()
    results.append(pool.apply_async(testArgs, (args1, args2...)))

pool.close()
pool.join()

因為計算的每條線都可以獨立運作，非常適合平行運算，所以core越多越有利

所以如果要比core多

現在core最多的東西

應該就是....

近幾年非常流行GPU運算

但是事情沒有這麼容易

因為如果你要用Cuda

你必需要寫C...

但是....

偶然間讓我發現到一個東西

PyCuda!!

馬上讓我們來看看這怎麼用

PyCuda 101

import pycuda.autoinit
import pycuda.driver as drv
import numpy

from pycuda.compiler import SourceModule
mod = SourceModule("""
    __global__ void multiply_them(float *dest, float *a, float *b)
    {
      const int i = threadIdx.x;
      dest[i] = a[i] * b[i];
    }
""")

multiply_them = mod.get_function("multiply_them")

a = numpy.random.randn(400).astype(numpy.float32)
b = numpy.random.randn(400).astype(numpy.float32)

dest = numpy.zeros_like(a)
multiply_them(
        drv.Out(dest), drv.In(a), drv.In(b),
        block=(400,1,1), grid=(1,1))

print dest-a*b