新智元推薦

來源:量化投資與機器學習

作者：一心想錯

新智元啟動 2017 最新一輪大招聘：COO、總編、主筆、運營總監、視覺總監等８大職位全面開放。

新智元為COO和執行總編提供最高超百萬的年薪激勵；為骨幹員工提供最完整的培訓體系、高於業界平均水平的工資和獎金。加盟新智元，與人工智慧業界領袖攜手改變世界。

簡歷投遞：jobs@aiera.com.cnHR 微信：13552313024

【新智元導讀】本文利用周志華教授gcForest（多粒度級聯森林）演算法，針對股指期貨漲跌的預測進行超詳細分析，並提供代碼實現。

公號介紹：量化投資與機器學習公眾號作為金融科技類微信公眾號，彙集了一群來自北京、清華、復旦、同濟、武大、華中科技大、上財、中大、中科大、人大、東北財大、湖大、新加坡國立大學等海內外優秀院校畢業的博士、碩士和相關研究和從業的專業人員，為大家提供優質的知識食糧。

gcForest Algorithm

對於周志華教授的文章，網上已經有人做出很詳細的解釋啦。我們對論文進行簡單描述之後，然後直接從策略開始講起。

gcForest(multi-Grained Cascade forest 多粒度級聯森林)是周志華教授最新提出的新的決策樹集成方法。這種方法生成一個深度樹集成方法(deep forest ensemble method)，使用級聯結構讓gcForest學習。gcForest模型把訓練分成兩個階段：Multi-Grained Scanning和Cascade Forest。Multi-Grained Scanning生成特徵，Cascade Forest經過多個森林多層級聯得出預測結果。

它的表徵學習能力可以通過對高維輸入數據的多粒度掃描而進行加強。串聯的層數也可以通過自適應的決定從而使得模型複雜度不需要成為一個自定義的超參數，而是一個根據數據情況而自動設定的參數。值得注意的是，gcForest會比DNN有更少的超參數，更好的一點在於gcForest對參數是有非常好的魯棒性，哪怕用默認參數也可以獲得很棒的結果。

因為決策樹其實是在特徵空間中不斷劃分子空間，並且給每個子空間打上標籤（分類問題就是一個類別，回歸問題就是一個目標值），所以給予一條測試樣本，每棵樹會根據樣本所在的子空間中訓練樣本的類別佔比生成一個類別的概率分布，然後對森林內所有樹的各類比例取平均，輸出整個森林對各類的比例。例如下圖所示，這是根據圖1的三分類問題的一個簡化森林，每個樣本在每棵樹中都會找到一條路徑去找到自己對應的葉節點，而同樣在這個葉節點中的訓練數據很可能是有不同類別的，我們可以對不同類別進行統計獲取各類的比例，然後通過對所有樹的比例進行求均值生成整個森林的概率分布。

多粒度掃描

多粒度掃描其實是引用了類似CNN的一個滑動窗口，例如說我們現在有一個400維的樣本輸入，現在設定採樣窗口是100維的，那我們可以通過逐步的採樣，最終獲得301個子樣本（因此這裡默認的採樣步長是1，所以得到的子樣本個數 = (400-100)/1 + 1）。如果輸入的是一個20*20的圖片，利用一個10*10的採樣窗口，就可以獲得121個子樣本（對每行和每列都是 (20-10)/1 + 1 = 11，11*11 = 121）。所以，整個多粒度掃描過程就是：先輸入一個完整的P維樣本，然後通過一個長度為k的採樣窗口進行滑動採樣，得到S = (P - K)/1+1 個k維特徵子樣本向量，接著每個子樣本都用於完全隨機森林和普通隨機森林的訓練並在每個森林都獲得一個長度為C的概率向量，這樣每個森林會產生長度為S*C的表徵向量（就是經過隨機森林轉換並拼接的概率向量），最後把每層的F個森林的結果拼接在一起得到本層輸出。

演算法實現

鑒於此，在Github上，已經有人實現了演算法代碼。在這裡我們提供一個基於python3的代碼實現方法。選擇採用scikit學習語法以方便使用，下面將介紹如何使用它。

GCForest.py 源碼如下，首先需要將此模塊導入到根目錄並命名為GCForest.py，當然最好是從github克隆下來。

gcForest in Python

Status : under development

gcForestis an algorithm suggested in Zhou and Feng 2017. It uses a multi-grain scanning approach for data slicing and a cascade structure of multiple random forests layers (see paper for details).

gcForesthas been first developed as a Classifier and designed such that the multi-grain scanning module and the cascade structure can be used separately. During development I"ve paid special attention to write the code in the way that future parallelization should be pretty straightforward to implement.

Prerequisites

The present code has been developed under python3.x. You will need to have the following installed on your computer to make it work :

• Python 3.x

• Numpy >= 1.12.0

• Scikit-learn >= 0.18.1

• jupyter >= 1.0.0 (only useful to run the tuto notebook)

You can install all of them using pip install :

$ pip3 install requirements.txt

Using gcForest

The syntax uses the scikit learn style with a .fit function to train the algorithm and a .predict function to predict new values class. You can find two examples in the jupyter notebook included in the repository.

from GCForest import * gcf = gcForest( **kwargs ) gcf.fit(X_train, y_train) gcf.predict(X_test)

Notes

I wrote the code from scratch in two days and even though I have tested it on several cases I cannot certify that it is a 100% bug free obviously. Feel free to test it and send me your feedback about any improvement and/or modification!

Known Issues

Memory comsuption when slicing dataThere is now a short naive calculation illustrating the issue in the notebook. So far the input data slicing is done all in a single step to train the Random Forest for the Multi-Grain Scanning. The problem is that it might requires a lot of memory depending on the size of the data set and the number of slices asked resulting in memory crashes (at least on my Intel Core 2 Duo).

I have recently improved the memory usage (from version 0.1.4) when slicing the data but will keep looking at ways to optimize the code.

OOB score errorDuring the Random Forests training the Out-Of-Bag (OOB) technique is used for the prediction probabilities. It was found that this technique can sometimes raises an error when one or several samples is/are used for all trees training.

A potential solution consists in using cross validation instead of OOB score although it slows down the training. Anyway, simply increasing the number of trees and re-running the training (and crossing fingers) is often enough.

Built With

• PyCharmcommunity edition

• memory_profiler libra

License

This project is licensed under the MIT License (see LICENSE for details)

Early Results

(will be updated as new results come out)

• Scikit-learn handwritten digits classification :

  training time ~ 5min

  accuracy ~ 98%

部分代碼：

import itertools
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score __author__ = "Pierre-Yves Lablanche"
__email__ = "plablanche@aims.ac.za"
__license__ = "MIT"
__version__ = "0.1.3"
__status__ = "Development"

# noinspection PyUnboundLocalVariable
class gcForest(object): def __init__(self, shape_1X=None, n_mgsRFtree=30, window=None, stride=1, cascade_test_size=0.2, n_cascadeRF=2, n_cascadeRFtree=101, cascade_layer=np.inf, min_samples_mgs=0.1, min_samples_cascade=0.05, tolerance=0.0, n_jobs=1): """ gcForest Classifier.

關於規模

目前gcForest實現中的主要技術問題是在輸入數據時的內存使用情況。真實的計算實際上可以讓您了解演算法將處理的對象的數量和規模。

計算C類[l，L]大小N維的問題，初始規模為：

Slicing StepIf my window is of size [wl,wL] and the chosen stride are [sl,sL] then the number of slices per sample is :

Obviously the size of slice is [wl,wL]hence the total size of the sliced data set is :

This is when the memory consumption is its peak maximum.

Class Vector after Multi-Grain ScanningNow all slices are fed to the random forest to generate class vectors. The number of class vector per random forest per window per sample is simply equal to the number of slices given to the random forest

Hence, if we have Nrfrandom forest per window the size of a class vector is (recall we have N samples and C classes):

And finally the total size of the Multi-Grain Scanning output will be:

This short calculation is just meant to give you an idea of the data processing during the Multi-Grain Scanning phase. The actual memory consumption depends on the format given (aka float, int, double, etc.) and it might be worth looking at it carefully when dealing with large datasets.

預測每根K線漲跌

獲取每根k線的交易數據後，把open,close,high,low,volume,ema, macd, linreg, momentum, rsi, var, cycle, atr作為特徵指標，下根K線漲跌作為預測指標

#獲取當前時間
from datetime import datetime now = datetime.now


startDate = "2010-4-16"
endDate = now
#獲取滬深300股指期貨數據，頻率為1分鐘
df=get_price("IF88", start_date=startDate, end_date=endDate, frequency="1d", fields=None, country="cn") open = df["open"].values close = df["close"].values volume = df["volume"].values high = df["high"].values low = df["low"].values

import talib as ta
import pandas as pd
import numpy as np
from sklearn import preprocessing ema = ta.EMA(close, timeperiod=30).tolist macd = ta.MACD(close, fastperiod=12, slowperiod=26, signalperiod = 9)[0].tolist momentum = ta.MOM(close, timeperiod=10).tolist rsi = ta.RSI(close, timeperiod=14).tolist linreg = ta.LINEARREG(close, timeperiod=14).tolist var = ta.VAR(close, timeperiod=5, nbdev=1).tolist#獲取當前的收盤價的希爾伯特變換
cycle = ta.HT_DCPERIOD(close).tolist#獲取平均真實波動範圍指標ATR,時間段為14
atr = ta.ATR(high, low, close, timeperiod=14).tolist#把每根k線的指標放入數組X中，並轉置
X = np.array([open,close,high,low,volume,ema, macd, linreg, momentum, rsi, var, cycle, atr]).T#輸出可知數組X包含了ema, macd, linreg等13個指標數值
X[2]

array([ 3215. , 3267.2, 3281.2, 3208. , 114531. , nan, nan, nan, nan, nan, nan, nan, nan])

y= c=close[0]
#用i遍歷整個數據集
for i in range(1, len(X)):
#如果高點突破參考線的1.0015倍，即上漲 if (close[i]>close[i-1]):
#把參考點加到列表basicLine里，並且新參考點變為原來的1.0015倍， y.append(1) elif (close[i]#添加最後一個數據的標籤為1
y.append(1)

#把y轉化為ndarray數組
y=np.array(y)
#輸出驗證標籤集是否準確
print(len(y))
for i in range(1, 10): print(close[i],y[i],i)

1663 3214.6 1 1 3267.2 0 2 3236.2 0 3 3221.2 0 4 3219.6 0 5 3138.8 0 6 3129.0 0 7 3083.8 1 8 3107.0 0 9

#把數據集分解成隨機的訓練和測試子集， 參數test_size表示測試集所佔比例
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.33)
#輸出可知測試特徵集為維度是50*4的數組ndarray
X_te.shape


(549, 13)

首先調用和訓練演算法. 參數shape_1X在這裡是指某一樣本的維度。我把維度也作為圖像特徵輸入到機器里. 顯然，它與iris數據集並不是很相關，但仍然需要定義 .

0.1.3版本可輸入整數作為 shape_1X參數。

gcForest參數說明

shape_1X:單個樣本元素的形狀[n_lines，n_cols]。 調用mg_scanning時需要！對於序列數據，可以給出單個int。

n_mgsRFtree:多粒度掃描期間隨機森林中的樹木數量。

window：int（default = None）多粒度掃描期間使用的窗口大小列表。如果「無」，則不進行切片。

stride：int（default = 1）切片數據時使用的步驟。

cascade_test_size：float或int（default = 0.2）級聯訓練集分裂的分數或絕對數。

n_cascadeRF：int（default = 2）級聯層中隨機森林的數量,對於每個偽隨機森林，創建完整的隨機森林，因此一層中隨機森林的總數將為2 * n_cascadeRF。

n_cascadeRFtree：int（default = 101）級聯層中單個隨機森林中的樹數。

min_samples_mgs：float或int（default = 0.1）節點中執行拆分的最小樣本數 在多粒度掃描隨機森林訓練期間。 如果int number_of_samples = int。 如果float，min_samples表示要考慮的初始n_samples的分數。

min_samples_cascade：float或int（default = 0.1）節點中執行拆分的最小樣本數 在級聯隨機森林訓練期間。 如果int number_of_samples = int。 如果float，min_samples表示要考慮的初始n_samples的分數。

cascade_layer：int（default = np.inf）允許的最大級聯級數。 有用的限制級聯的結構。

tolerance：float（default= 0.0）聯生長的精度差,整個級聯的性能將在驗證集上進行估計， 如果沒有顯著的性能增益，訓練過程將終止

n_jobs：int（default = 1）任意隨機森林適合并預測的並行運行的工作數量。 如果為-1，則將作業數設置為核心數。

#shape_1X樣本維度，window為多粒度掃描（Multi-Grained Scanning）演算法中滑動窗口大小，
#用於掃描原始數據，tolerance為級聯生長的精度差,整個級聯的性能將在驗證集上進行估計，
#如果沒有顯著的性能增益，訓練過程將終止#gcf = gcForest(shape_1X=4, window=2, tolerance=0.0)
#gcf = gcForest(shape_1X=[13,13], window=2, tolerance=0.0)

gcf = gcForest(shape_1X=13, n_mgsRFtree=100, window=6, stride=2, cascade_test_size=0.2, n_cascadeRF=4, n_cascadeRFtree=101, cascade_layer=np.inf, min_samples_mgs=0.1, min_samples_cascade=0.1, tolerance=0.0, n_jobs=1) gcf.fit(X_tr, y_tr)

Slicing Sequence... Training MGS Random Forests... Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.5577889447236181 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.521608040201005

#shape_1X樣本維度，window為多粒度掃描（Multi-Grained Scanning）演算法中滑動窗口大小，
#用於掃描原始數據，tolerance為級聯生長的精度差,整個級聯的性能將在驗證集上進行估計，
#如果沒有顯著的性能增益，訓練過程將終止#gcf = gcForest(shape_1X=4, window=2, tolerance=0.0)
#gcf = gcForest(shape_1X=[13,13], window=2, tolerance=0.0)

gcf = gcForest(shape_1X=[1,13], window=[1,6],) gcf.fit(X_tr, y_tr)

Slicing Sequence... Training MGS Random Forests... Slicing Sequence... Training MGS Random Forests... Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.5964125560538116 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.5695067264573991

參數改為shape_1X=[1,13], window=[1,6]後訓練集達到0.59，不理想，這裡只是拋磚引玉，調參需要大神指導。

Now checking the prediction for the test set:

現在看看測試集的預測值：

pred_X = gcf.predict(X_te) print(len(pred_X)) print(len(y_te)) print(pred_X)

Slicing Sequence... Slicing Sequence... 549 549 [1 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1 0 1 0 1 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0等

#最近預測
for i in range(1,len(pred_X)): print(y_te[-i],pred_X[-i],-i)

0 1 -1 0 0 -2 1 0 -3 1 0 -4 0 1 -5
等

# 保存每一天預測的結果，如果某天預測對了，保存1，如果某天預測錯了，保存-1
result_list =
# 檢查預測是否成功

import matplotlib.pyplot as plt
#將準確率曲線畫出來
x = range(0, len(result_list)) y =
#z=
for i in range(0, len(result_list)):
#y.append((1 + float(sum(result_list[:i])) / (i+1)) / 2) y.append( float(sum(result_list[:i])) / (i+1)) print("最近",j,"次準確率",y[-1]) print(x, y) line, = plt.plot(x, y) plt.show

549 549 最近 549 次準確率 0.5300546448087432 range(0, 549) [0.0, 0.0, 0.3333333333333333, 0.25等

#評估準確率
# evaluating accuracy
accuracy = accuracy_score(y_true=y_te, y_pred=pred_X) print("gcForest accuracy : {}".format(accuracy))

gcForest accuracy : 0.5300546448087432

預測結果很一般，不過還是有效的。

預測漲跌看起不是那麼靠譜，但識別手寫數字還是相當牛逼的。

下面只貼出結果：

# loading the data

digits = load_digits X = digits.data y = digits.target X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.4) gcf = gcForest(shape_1X=[7,8], window=[4,6], tolerance=0.0, min_samples_mgs=10, min_samples_cascade=7)
#gcf = gcForest(shape_1X=13, window=13, tolerance=0.0, min_samples_mgs=10, min_samples_cascade=7)
gcf.fit(X_tr, y_tr)

Slicing Images... Training MGS Random Forests... Slicing Images... Training MGS Random Forests... Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.9814814814814815 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.9814814814814815

# evaluating accuracy
accuracy = accuracy_score(y_true=y_te, y_pred=pred_X) print("gcForest accuracy : {}".format(accuracy))

gcForest accuracy : 0.980528511821975

厲害了，簡單的參數都能使手寫數字識別的準確率高達98%

單獨利用多粒度掃描和級聯森林

由於多粒度掃描和級聯森林模塊是相當獨立的，因此可以單獨使用它們。如果給定目標「y」，代碼將自動使用它進行訓練，否則它會調用最後訓練的隨機森林來分割數據。

gcf = gcForest(shape_1X=[8,8], window=5, min_samples_mgs=10, min_samples_cascade=7) X_tr_mgs = gcf.mg_scanning(X_tr, y_tr)

Slicing Images... Training MGS Random Forests...

It is now possible to use the mg_scanning output as input for cascade forests using different parameters. Note that the cascade forest module does not directly return predictions but probability predictions from each Random Forest in the last layer of the cascade. Hence the need to first take the mean of the output and then find the max.

gcf = gcForest(tolerance=0.0, min_samples_mgs=10, min_samples_cascade=7) _ = gcf.cascade_forest(X_tr_mgs, y_tr)

Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.9722222222222222 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.9907407407407407 Adding/Training Layer, n_layer=3 Layer validation accuracy = 0.9814814814814815

import numpy as np pred_proba = gcf.cascade_forest(X_te_mgs) tmp = np.mean(pred_proba, axis=0) preds = np.argmax(tmp, axis=1) accuracy_score(y_true=y_te, y_pred=preds) gcf = gcForest(tolerance=0.0, min_samples_mgs=20, min_samples_cascade=10) _ = gcf.cascade_forest(X_tr_mgs, y_tr) pred_proba = gcf.cascade_forest(X_te_mgs) tmp = np.mean(pred_proba, axis=0) preds = np.argmax(tmp, axis=1) accuracy_score(y_true=y_te, y_pred=preds)

0.97774687065368571

Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.9629629629629629 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.9675925925925926 Adding/Training Layer, n_layer=3 Layer validation accuracy = 0.9722222222222222 Adding/Training Layer, n_layer=4 Layer validation accuracy = 0.9722222222222222

0.97218358831710705

Skipping mg_scanning

It is also possible to directly use the cascade forest and skip the multi grain scanning step.

gcf = gcForest(tolerance=0.0, min_samples_cascade=20) _ = gcf.cascade_forest(X_tr, y_tr)
pred_proba = gcf.cascade_forest(X_te) tmp = np.mean(pred_proba, axis=0) preds = np.argmax(tmp, axis=1) accuracy_score(y_true=y_te, y_pred=preds)

Adding/Training Layer, n_layer=1 Layer validation accuracy = 0.9583333333333334 Adding/Training Layer, n_layer=2 Layer validation accuracy = 0.9675925925925926 Adding/Training Layer, n_layer=3 Layer validation accuracy = 0.9583333333333334

0.94297635605006958

文本由微信公眾號量化投資與機器學習授權轉載，特此感謝！

新智元招聘

職位：客戶經理

職位年薪：12 - 25萬（工資+獎金）

工作地點：北京-海淀區

所屬部門：客戶部

彙報對象：客戶總監

工作年限：3 年

語 言：英語 + 普通話

學歷要求：全日制統招本科

職位描述：

1. 精準把握客戶需求和公司品牌定位，策劃撰寫合作方案；

2. 思維活躍、富有創意，文字駕馭能力強，熟練使用PPT，具有良好的視覺欣賞及表現能力，PS 能力優秀者最佳；

3. 熱情開朗，擅長人際交往，良好的溝通和協作能力，具有團隊精神；

4. 優秀的活動籌備與執行能力，較強的抗壓能力和應變能力，適應高強度工作；

5. 有4A、公關公司工作經歷優先；

6. 對高科技尤其是人工智慧領域有強烈興趣者加分。

崗位職責：

參與、管理、跟進上級指派的項目進展，確保計劃落實。制定、參與或協助上層執行相關的政策和制度。定期向公司提供準確的市場資訊及所屬客戶信息，分析客戶需求，維護與指定公司關鍵顧客的關係，積極尋求機會發展新的業務。建立並管理客戶資料庫，跟蹤分析相關信息。

應聘郵箱：jobs@aiera.com.cn

HR微信：13552313024

新智元歡迎有志之士前來面試，更多招聘崗位請點擊【新智元招聘】查看。