Le 100e article original, axé sur "la croissance personnelle et la liberté de richesse, la logique du fonctionnement mondial, l'investissement quantitatif de l'IA".
Aujourd'hui c'est le 100ème jour ! 100 jours d'affilée, y compris les week-ends, c'est bien. Le plan des 1000 jours est bien parti.
J'ai observé et analysé qu'il y a principalement deux types d'utilisateurs dans le groupe des membres de la planète, l'un est des ingénieurs, des experts en algorithmes, etc., qui connaissent python et s'intéressent à la quantification financière ; l'autre est des praticiens de l'industrie financière, du capital-investissement, fonds, sociétés de titres ou banques , effectuant eux-mêmes des recherches et des analyses ou la gestion d'actifs. Le dénominateur commun est que tout le monde s'intéresse à la quantification.
Du point de vue de la voie technique générale, la quantification de l'IA est définitivement la bonne direction, il n'y a pas lieu d'en douter, mais ce n'est qu'au stade où elle en est.
Les besoins de chacun comportent plusieurs aspects : Tout d'abord, un système de connaissances quantitatif : comment passer systématiquement de l'entrée à la maîtrise nécessite un système de connaissances plus structuré. Le but ultime, bien sûr, est d'élaborer une stratégie et de faire une offre ferme. Si vous voulez le simplifier à un seul objectif, tout le monde est pareil : faire une stratégie d'offre d'entreprise pérenne .
Bien sûr, une stratégie n'est pas une chose statique et unique. C'est un système qui doit être itératif et évoluera avec le marché lui-même. Il n'y a pas de Saint Graal éternel. C'est la plus grande différence entre la finance et la physique. . Les lois de la physique sont là, que vous les découvriez ou non, elles ne changeront pas, elles n'attendent que vous pour les découvrir. Si le modèle financier est utilisé par trop de gens, il n'y aura pas d'issue, et la folie de la nature humaine se superposera.
Nous avons besoin d'une "usine stratégique" et d'une "chaîne de montage" au lieu d'attendre de produire une stratégie ultime. Nous avons construit cette usine de stratégie, en intégrant le framework orienté IA de qlib avec le trading événementiel et réel de backtrader, ainsi que l'interface graphique de wxPython .
Hier, nous avons appliqué l'apprentissage automatique à la quantification et avons dressé une brève liste : Quantification de l'IA et processus d'apprentissage automatique : des données au modèle . Continuez aujourd'hui.
01 Pack de préparation des données
Avant d'encapsuler csv et arctic, j'ai ajouté hdf5 aujourd'hui.
# encoding:utf8
import datetime
import pandas as pd
class Hdf5DataFeed :
def __init__(self, db_name='index.h5') :
self.code_dfs = {}
def get_df(self, code, db=None) :
si code dans self. code_dfs.keys() :
renvoie self.code_dfs[code]
avec pd.HDFStore('../../data/hdf5/index.h5') comme magasin :
#print(store.keys())
df = store[ code]
#print(df)
df = df[['open','high','low','close','volume','code']] self.code_dfs[code] = df return df
def
get_one_df_by_codes
( self, codes) :
dfs = [self.get_df(code) pour le code dans les codes]
df_all = pd.concat(dfs, axis=0)
df_all.dropna(inplace=True)
df_all.sort_index(inplace=True)
return df_all
def get_returns_df(self, codes):
df = self.get_one_df_by_codes(codes)
all = pd. pivot_table(df, index='date', values='close', columns=['code']) return_df
= all.pct_change()
return_df.dropna(inplace=True)
return return_df
def get_returns_df_ordered(self, codes):
dfs = []
pour le code dans les codes :
df = self.get_df(code, cols=['close'])
close = df['close']
close.name = code
dfs.ajouter (fermer)
all = pd.concat(dfs, axis=1)
renvoie_df = all.pct_change()
renvoie_df.dropna(inplace=True)
return renvoie_df
si __name__ == '__main__':
feed = Hdf5DataFeed()
print(feed.get_df('SPX '))
df = feed.get_one_df_by_codes(['000300.SH','000905.SH','SPX'])
print(df)
02 Ingénierie des fonctionnalités
Pour l'ingénierie des fonctionnalités, "l'expression factorielle" est préférée.
champs += [
"Std(Abs($close/Ref($close, 1)-1)*$volume, 30)/(Mean(Abs($close/Ref($close, 1)-1)*$volume , 30)+1e-12)"
]
noms += ['WVMA30']
En utilisant des expressions factorielles, des formules complexes peuvent être écrites, similaires à alpha101 de worldquant. Si vous le codez vous-même, il est non seulement inefficace, mais également sujet aux erreurs.
import pandas as pd
from engine.datafeed.expr.expr_mgr import ExprMgr
class Dataloader:
def __init__(self):
self.expr = ExprMgr()
def load(self, codes, names, fields):
dfs = []
for code in codes :
df = pd.DataFrame()
pour nom, champ dans zip(noms, champs) :
exp = self.expr.get_expression(champ)
se = exp.load(code)
df[nom] = se
df['code'] = code
dfs.append(df)
all = pd.concat(dfs)
all.sort_index(ascending=True, inplace=True)
all.dropna(inplace=True)
return all
if __name__ == '__main__' :
noms = []
champs = []
champs += ["($high-$low)/$open"]
noms += ['KLEN']
champs += ["$close"]
noms += ['close']
champs += ["$close/Ref($close,1) - 1"]
noms += ['return_1']
champs += ["Ref($close,-1)/$ close - 1"]
noms += ['label']
all = Dataloader().load(['SPX', '000300.SH'], noms, champs)
print(all)
Ingénierie complète des caractéristiques des données et étiquetage automatique ( l'expression du facteur ici est indépendante du code qlib, et je n'utilise pas la base de données qlib, mais j'utilise le hdf5 plus simple )
03 modèle
Construisez un modèle profond basé sur keras :
import random
import numpy as np
import tensorflow as tf
from keras.layers import Dense, Dropout
from keras.models import Sequential
from keras.regularizers import l1
from keras.optimizers import Adam
from sklearn.metrics import precision_score
def set_seeds(seed=100):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
set_seeds()
optimiseur = Adam(learning_rate=0.0001)
def create_model(hl=2, hu=128, dropout=False, rate= 0.3,
regularize=False, reg=l1(0.0005),
optimizer=optimizer, input_dim=None) : # input_dim = len(features)
si non régularisé :
reg = None
model = Sequential()
model.add(Dense(hu, input_dim=input_dim,
activity_regularizer=reg,
activation='relu'))
if dropout:
model.add(Dropout(rate, seed=100))
for _ in range(hl ):
model.add(Dense(hu, activation='relu',
activity_regularizer=reg))
si abandon :
model.add(Dropout(rate, seed=100))
model.add(Dense(1, activation='sigmoid') ))
model.compile(loss='binary_crossentropy',
optimiser=optimizer,
metrics=['accuracy'])
renvoie le modèle
si __name__ == '__main__' :
modèle set_seeds()
= create_model(hl=2, hu=64)
Chaque lien ici doit être continuellement renforcé et optimisé, mais ce cadre se stabilisera progressivement.
Pour le code et les données de tous les systèmes, veuillez vous rendre sur la planète pour le télécharger.
Quantification de l'IA et processus d'apprentissage automatique : des données au modèle