def __init__(self):
stock_code = '005930'
start_date = '2010-03-01'
end_date = '2015-03-04'
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR,
'data/chart_data/{}.csv'.format(stock_code)))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[(training_data['date'] >= self.start_date) &
(training_data['date'] <= self.end_date)]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
chart_data['data']= pd.to_datetime(chart_data.date).astype(np.int64)/1000000
data = torch.from_numpy(chart_data.values)
self.data = torch.stack([data[:,0],data[:,4],data[:,5]],dim=1).float()
self.data = self.data - self.data.mean(dim=0)
self.data = self.data/self.data.std(0)
self.count_max= self.data.size(0)
def prepare_data(stock_code, market_code, start_date, end_date):
# 종목 데이터 준비
chart_data = data_manager.load_chart_data(stock_code)
prep_data = data_manager.preprocess_close_volume(chart_data, WINDOWS)
data1 = data_manager.build_training_data_close_volume_ratio(prep_data,'stock', WINDOWS)
data1 = data_manager.preprocess_inst_frgn(data1, WINDOWS)
# market 데이터 준비
market_data = data_manager.load_market_data(market_code)
prep_data = data_manager.preprocess_close_volume(market_data, WINDOWS)
data2 = data_manager.build_training_data_close_volume_ratio(prep_data,'market', WINDOWS)
# 종목 + market data merge
data = pd.merge(data1, data2, on='date', suffixes=('', '_y'))
# 기간 필터링
data = data[(data['date'] >= start_date) & (data['date'] <= end_date)]
data = data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = data[features_chart_data]
# 추가 feature 데이터 분리
drop_features = ['date', 'open', 'high', 'low', 'close', 'volume',
'open_y', 'high_y', 'low_y', 'close_y', 'volume_y']
for window in WINDOWS:
drop_features.append('close_ma{}'.format(window))
drop_features.append('volume_ma{}'.format(window))
drop_features.append('close_ma{}_y'.format(window))
drop_features.append('volume_ma{}_y'.format(window))
training_data = data.drop(columns=drop_features)
return chart_data, training_data
def _pre_process(self):
chart_data = data_manager.load_chart_data('test.csv')
print("chart_data:", chart_data.head())
prep_data = data_manager.preprocess(chart_data)
print("prep_data:", prep_data)
training_data = data_manager.build_training_data(prep_data)
print("training_data:", training_data)
def reset(self):
stock_code = np.random.choice([
'005930', '000270', '000660', '005380', '005490', '009240',
'009540'
])
self.prev_action = 0
self.count = 0
self.balance = self.init_money
self.num_stocks = 0
self.sum_action = 0
chart_data = data_manager.load_chart_data(
os.path.join('./', 'data/chart_data/{}.csv'.format(stock_code)))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
start = random.randint(self.view_seq,
(len(training_data) - self.count_max - 200))
training_data = training_data[start - self.view_seq:start +
self.count_max + 200]
# training_data = training_data[(training_data['date'] >= self.start_date) &
# (training_data['date'] <= self.end_date)]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = [
'date', 'open', 'high', 'low', 'close', 'volume'
]
self.chart_data = training_data[features_chart_data]
self.chart_data['date'] = pd.to_datetime(self.chart_data.date).astype(
np.int64) / 1e12
# 학습 데이터 분리
features_training_data = [
'open_lastclose_ratio', 'high_close_ratio', 'low_close_ratio',
'close_lastclose_ratio', 'volume_lastvolume_ratio',
'close_ma5_ratio', 'volume_ma5_ratio', 'close_ma10_ratio',
'volume_ma10_ratio', 'close_ma20_ratio', 'volume_ma20_ratio',
'close_ma60_ratio', 'volume_ma60_ratio', 'close_ma120_ratio',
'volume_ma120_ratio'
]
training_data = training_data[features_training_data]
self.data = torch.from_numpy(training_data.values).float()
state = self.data[self.count:self.count + self.view_seq].view(1, -1)
state = torch.cat(
[state, torch.Tensor([self.sum_action]).view(1, -1)], dim=1)
return state
pass
def __init__(self, stock_list, start, end):
self.stock_list = stock_list
self.start_date = start
self.end_date = end
data_base = []
for stock_code in self.stock_list:
# 주식 데이터 준비
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR,
'data/chart_data/{}.csv'.format(stock_code)))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[
(training_data['date'] >= self.start_date)
& (training_data['date'] <= self.end_date)]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = [
'date', 'open', 'high', 'low', 'close', 'volume'
]
chart_data = training_data[features_chart_data]
chart_data['date'] = pd.to_datetime(chart_data.date).values.astype(
np.int64)
#차트 index축을 date 로변경
# chart_data.set_index('date', inplace=True)
chart_data = torch.from_numpy(chart_data.values)
data_base.append(chart_data)
data_base = torch.cat(data_base, dim=1).float()
scaled_data = (data_base - data_base.mean(dim=0))
self.scaled_data = scaled_data / scaled_data.std()
self.max_count = self.scaled_data.size(0)
model_ver = '20180202000545'
# 로그 기록
log_dir = os.path.join(settings.BASE_DIR, 'logs/%s' % stock_code)
timestr = settings.get_time_str()
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (stock_code, timestr)), encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler], level=logging.DEBUG)
# 주식 데이터 준비
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR,
'data/chart_data/{}.csv'.format(stock_code)))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[(training_data['date'] >= '2018-01-01') &
(training_data['date'] <= '2018-01-31')]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
# 학습 데이터 분리
features_training_data = [
log_dir = os.path.join(settings.BASE_DIR, 'logs/%s' % COIN)
timestr = settings.get_time_str()
if not os.path.exists('logs/%s' % COIN):
os.makedirs('logs/%s' % COIN)
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (COIN, timestr)),
encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler],
level=logging.DEBUG)
coin_chart = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR, 'data/chart_data/{}.csv'.format(COIN)))
print("coin chart get")
prep_data = data_manager.preprocess(coin_chart)
training_data = data_manager.build_training_data(prep_data)
# start_date = '2018-05-24 00:00:00'
# end_date = '2018-07-10 00:00:00'
training_data = training_data[(training_data['date'] >= FROM)
& (training_data['date'] < TO)]
training_data = training_data.dropna()
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
coin_chart = training_data[features_chart_data]
log_dir = os.path.join(settings.BASE_DIR, 'logs/%s' % stock_code)
timestr = settings.get_time_str()
if not os.path.exists('logs/%s' % stock_code):
os.makedirs('logs/%s' % stock_code)
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (stock_code, timestr)),
encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler],
level=logging.DEBUG)
# 주식 데이터 준비
chart_data = data_manager.load_chart_data(stock_code)
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
# training_data = training_data[(training_data['date'] >= '2018-01-01 00:00:00') &
# (training_data['date'] <= '2018-08-28 12:00:00')]
training_data = training_data[(training_data['date'] >= '2018-08-01')
& (training_data['date'] <= '2018-09-27')]
training_data = training_data.dropna()
# print("Training DATA RANGE : ", training_data);
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
import matplotlib.pyplot as plt
import pylab
if __name__ == '__main__':
#매번 조정해줄 변수들
stock_code = 'TUSD' # coin name
model_ver = '' # model to load
#model save/load 에사용할 정보
model_code = 'price'
price_model_ver = 'price_{}'.format(model_ver)
timestr = settings.get_time_str()
########################### importing data part ###########################
# 차트 데이터 준비
chart_data = data_manager.load_chart_data('./{}BTC.csv'.format(stock_code))
training_data = data_manager.build_training_data(chart_data)
# 기간 필터링
training_data = training_data[
(training_data['date'] >= '09:00 2013-12-27')
& (training_data['date'] <= '21:00 2019-01-21')]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
# 학습 데이터 분리
features_training_data = [
'high_low_ratio',
'open_close_ratio',
'high_open_ratio',
'low_open_ratio',
def __init__(self):
stock_code='BTCUSDT'
global timestr #global 함수로 불러와 바로 사용
model_ver=timestr
self.dataclose = self.datas[0].close
log_dir = os.path.join(settings.BASE_DIR, 'logs/%s' % stock_code)
timestr = settings.get_time_str()
if not os.path.exists('logs/%s' % stock_code):
os.makedirs('logs/%s' % stock_code)
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (stock_code, timestr)), encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler], level=logging.DEBUG)
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR,
'{}'.format(stock_code)))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
training_data = training_data.loc['2018-07-01 01:00:00':]
features_chart_data = ['o_t', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
features_training_data = [
'high_close_ratio', 'low_close_ratio',
'close_lastclose_ratio', 'volume_lastvolume_ratio',
'close_ma5_ratio', 'volume_ma5_ratio',
'close_ma10_ratio', 'volume_ma10_ratio',
'close_ma20_ratio', 'volume_ma20_ratio',
'close_ma60_ratio', 'volume_ma60_ratio',
'close_ma120_ratio', 'volume_ma120_ratio',
'ema12','ema26','dn','mavg','up','pctB','macd','signal','cci'
]
training_data = training_data[features_training_data]
#print (training_data[:3])
training_data = training_data.dropna(axis=1)
chart_data=chart_data.dropna(axis=1)
#chart_data = chart_data.loc[:1530352800000]
#training_data = training_data.loc[:1530352800000]
delayed_reward_threshold=.001
lr=0.1
self.TRADING_TAX =0
self.TRADING_CHARGE=0
self.stock_code = stock_code
self.chart_data = chart_data
self.environment = Environment(chart_data)
self.agent = Agent(self.environment, delayed_reward_threshold=delayed_reward_threshold)
self.training_data = training_data
self.sample = None
self.pvdata=[]
self.training_data_idx = -1
self.num_features = self.training_data.shape[1] #+ self.agent.STATE_DIM
self.policy_network = PolicyNetwork(
input_dim=self.num_features, output_dim=self.agent.NUM_ACTIONS, lr=lr)
model_path=os.path.join(settings.BASE_DIR,
'models/{}/model_{}.h5'.format(stock_code,model_ver))
self.policy_network.load_model(model_path=model_path)
self.agent.set_balance(self.broker.getcash())
self.epsilon=0
self.num_stocks=0
df=pd.read_csv('out.csv')
self.stopit=df.loc[7692]['c_p'] #2903 4135 7692
# 로그 기록
log_dir = os.path.join(settings.BASE_DIR, 'logs/%s' % stock_code)
timestr = settings.get_time_str()
if not os.path.exists('logs/%s' % stock_code):
os.makedirs('logs/%s' % stock_code)
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (stock_code, timestr)), encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler], level=logging.DEBUG)
# 주식 데이터 준비
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR,
'data/chart_data/'), stock_code)
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[(training_data['Date'] >= '2015-01-01') &
(training_data['Date'] <= '2018-06-15')]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['Date', 'Open', 'High', 'Low', 'Close', 'Volume','Change']
chart_data = training_data[features_chart_data]
# 학습 데이터 분리
features_training_data = [
timestr = settings.get_time_str()
if not os.path.exists('logs/%s' % stock_code):
os.makedirs('logs/%s' % stock_code)
file_handler = logging.FileHandler(filename=os.path.join(
log_dir, "%s_%s.log" % (stock_code, timestr)),
encoding='utf-8')
stream_handler = logging.StreamHandler()
file_handler.setLevel(logging.DEBUG)
stream_handler.setLevel(logging.INFO)
logging.basicConfig(format="%(message)s",
handlers=[file_handler, stream_handler],
level=logging.DEBUG)
# 주식 데이터 준비
chart_data = data_manager.load_chart_data( # 차트 데이터를 Pandas DataFrame 객체로 불러온다
os.path.join(settings.BASE_DIR,
'data/chart_data/{}.csv'.format(stock_code)))
prep_data = data_manager.preprocess(
chart_data) # 불러온 차트 데이터를 전처리해서 학습 데이터를 만들 준비함
# training_data는 차트 데이터의 열들, 전처리에서 추가된 열들, 학습 데이터의 열들이 모두 포함된 데이터.
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[(training_data['date'] >= '2017-01-01') & (
training_data['date'] <= '2017-12-31')] # 2017년 전체 데이터 사용
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close',
'volume'] # 차트 데이터 열 지정
chart_data = training_data[features_chart_data] # 차트 데이터 분리
movies_sheets = []
for sheet in xlsx.sheet_names:
movies_sheets.append(xlsx.parse(sheet))
symbol = movies_sheets[10]
print(symbol)
if 'volume' in symbol:
symbol['volume'] = symbol['volume'].replace('-', np.nan)
symbol['volume'] = symbol['volume'].replace(r'[KM]+$', '', regex=True).astype(float) * \
symbol['volume'].astype(str).str.extract(r'[\d\.]+([KM]+)', expand=False).fillna(1)\
.replace(['K', 'M'], [10 ** 3, 10 ** 6]).astype(int)
symbol['volume'].fillna(method='ffill', inplace=True)
symbol['volume'].fillna(method='bfill', inplace=True)
# 주식 데이터 준비
chart_data = data_manager.load_chart_data(
os.path.join(settings.BASE_DIR, 'data/chart_data/wti.csv'))
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
# 기간 필터링
training_data = training_data[(training_data['date'] >= '2017-01-01')
& (training_data['date'] <= '2017-12-31')]
training_data = training_data.dropna()
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
# 학습 데이터 분리
features_training_data = [
'open_lastclose_ratio', 'high_close_ratio', 'low_close_ratio',
