def main(args):
if not os.path.exists(args.tdir):
os.mkdir(args.tdir)
print('[Create] %s' % args.tdir)
if args.cuda:
assert torch.cuda.is_available()
word_vocab, char_vocab, word_tensor, char_tensor, actual_maxwdlen = data_loader.load_data(
args.ddir, 65, FILE_NAME_LIST)
args.wvsize = word_vocab.size
train_reader = data_loader.DataReader(word_tensor[FILE_NAME_LIST[0]],
char_tensor[FILE_NAME_LIST[0]],
args.batch, args.maxlen)
valid_reader = data_loader.DataReader(word_tensor[FILE_NAME_LIST[1]],
char_tensor[FILE_NAME_LIST[1]],
args.batch, args.maxlen)
test_reader = data_loader.DataReader(word_tensor[FILE_NAME_LIST[2]],
char_tensor[FILE_NAME_LIST[2]],
args.batch, args.maxlen)
args.cvsize = char_vocab.size
args.wvsize = word_vocab.size
# preview_data(train_reader, word_vocab)
if args.seed:
torch.manual_seed(args.seed)
ker_sizes = [int(item.strip()) for item in args.ker_wid[1:-1].split(',')]
ker_feats = [int(item.strip()) for item in args.ker_num[1:-1].split(',')]
c2w = sum(ker_feats)
nlm = CNLM(cvsize=args.cvsize,
cedim=args.cedim,
wvsize=args.wvsize,
wedim=args.wedim,
cnn_size=c2w,
hdim=args.hdim,
kernel_sizes=ker_sizes,
kernel_features=ker_feats,
nhlayers=args.hlayers,
nrlayers=args.rlayers,
tie_weight=False,
droprate=args.drop)
print(nlm)
if args.cuda:
nlm.cuda()
opt = optim.SGD(nlm.parameters(), lr=args.lr)
train_eval(nlm, opt, train_reader, valid_reader, test_reader, args)
def train_algo(params):
"""
Fetch the total data to train the model on
"""
dataset = data.DataReader(params['data']['type'])
if params['data']['type'] == 'sql':
dataset.fetch_data(con=dbconfig.connections_[params['data']['source']](), query=params['data']['detail'])
elif params['data']['type'] == 'file':
dataset.fetch_data(file=params['data']['source'])
data_ = data.TrainingData(dataset, target='Put', data_split=params['data']['data_split'])
"""
Construct the MLP and optimizer arguments
"""
mlp_args = {'data':data_, **params['algo']}
"""
Define and train the network
"""
mdl = mlp.MLP(**mlp_args)
# train the network
train_history = mdl.sgd_train(**params['train'], optim_options=params['optim'])
# save the model
mdl.save(params['results']['model_path'])
# test the network
test_results = mdl.test()
# show results
mdl.test_scatter(test_results, save_fig= params['results']['test_scatter'])
mdl.plot_train_valid_curve(train_history, save_fig= params['results']['train_curve'])
#http://127.0.0.1:8050/
import dash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import State
import plotly.graph_objects as go
from datetime import date
from dateutil.relativedelta import relativedelta
import data
import flask
dr = data.DataReader()
pos = dr.getPos()
nu = dr.getNu()
min_date = dr.getEarliestDate()
max_date = dr.getLatestDate()
max_date_p1 = dr.getLatestDateP1()
max_date_m1m = dr.getLatestDateM1M()
dropdown_nu = [{
"label": "__all_transaction_types__",
"value": "__all_transaction_types__"
}]
for entry in nu:
dropdown_nu.append({"label": entry, "value": entry})
app = dash.Dash(__name__)
server = app.server
app.layout = html.Div([
html.Label("Users:"),
type=int,
default=5,
help='negative samples per training example')
parser.add_argument(
'--min_count',
type=int,
default=5,
help='number of word occurrences for it to be included in the vocabulary')
parser.add_argument('--gpu', default='0', help='GPU to use')
args = parser.parse_args()
if not os.path.exists(args.save_dir):
os.makedirs(args.save_dir)
my_data = data.DataReader(args.data, args.min_count)
dataset = data.Word2vecDataset(my_data, args.window_size, args.neg_num)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
collate_fn=dataset.collate)
if args.valid != None:
valid_dataset = data.ValidDataset(my_data, args.valid, args.window_size,
args.neg_num)
valid_dataloader = torch.utils.data.DataLoader(
valid_dataset,
batch_size=args.batch_size,
collate_fn=valid_dataset.collate)
vocab_size = len(my_data.word2id)
if args.model == 'sgns':
def BackTest(env, show_log=True, my_trick=False):
observation = env.reset()
while True:
observation, done = game_step(env, observation, train=False,
show_log=show_log, my_trick=my_trick)
if done:
break
if __name__ == "__main__":
start_date = "2011-01-01"
end_date = "2020-12-31"
panel_data = data.DataReader("TSLA", "yahoo", start_date, end_date)
dataset_1 = pd.DataFrame(data=panel_data['Adj Close']) # first step
# training, testing stage_1
for i in range(len(dataset_1)):
if str(dataset_1.index[i]) == '2019-12-31 00:00:00':
stage_1_training = dataset_1.iloc[:i + 1, :]
stage_1_testing = dataset_1.iloc[i + 1:, :]
index_data1 = Get_data(stage_1_training)
env_list1 = []
env_list2 = []
env_list1.append(Stock(stage_1_training[31:], index_data1))
env_list2.append(Stock(stage_1_testing[31:], index_data1))
import data
import matplotlib.pyplot as plt
from zipline.api import order, symbol, record, order_target
from zipline.algorithm import TradingAlgorithm
from zipline_poloniex.utils import setup_logging
import logging
# 1일 = 86400 / 5분 = 300 / 15분 = 900
gs = data.DataReader(currencyPair='USDT_BTC',
excahge='Poloniex',
start='2017.01.10 00:00:00',
end='2018.01.12 00:00:00',
period=300).make()
print('[*] 데이터 기초 정보')
print(gs.info())
print('[*] 종가 데이터만 셋팅')
gsData = gs[['close']]
print(gsData.head())
print('[*] 종가 컬럼명 변경')
gsData.columns = ['BTC']
print(gsData.head())
print('[*] 인덱스 타임 세계표준시로 변경')
gsData = gsData.tz_localize("UTC")
print(gsData)
__author__ = "Florian Wilhelm"
__copyright__ = "Florian Wilhelm"