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 _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)
# 로그 기록
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 = [
'open_lastclose_ratio', 'high_close_ratio', 'low_close_ratio',
'close_lastclose_ratio', 'volume_lastvolume_ratio',
def main():
#Directory Settings
DATASET_DIR = './dataset/'
EXPORT_DIR = './export/crnn_simple_cnn_frame/'
#Parameter Settings
MODE = 'frame'
DEVICE = 1 # 0 : cpu, 1 : gpu0, 2 : gpu1, ...
NUM_CLASS = 25 # 0 : Silence, 1 - 12: Major, 13 - 24: Minor, Don't change this parameter
EPOCH = 200
BATCH_SIZE = 32
SEQ_LENGTH = 128
LEARN_RATE = 0.001
parser = argparse.ArgumentParser()
parser.add_argument('--export_dir',
type=str,
default=EXPORT_DIR,
help='export directory')
parser.add_argument('--mode',
type=str,
default=MODE,
help='which mode? frame or beatsync')
parser.add_argument('--device',
type=int,
default=DEVICE,
help='which device? 0 : cpu, over 1 : gpu')
parser.add_argument('--epoch',
type=int,
default=EPOCH,
help='how many epoch?')
parser.add_argument('--batch_size',
type=int,
default=BATCH_SIZE,
help='how many batch?')
parser.add_argument('--seq_length',
type=int,
default=SEQ_LENGTH,
help='how much sequence length?')
parser.add_argument('--learn_rate',
type=float,
default=LEARN_RATE,
help='learning rate')
args = parser.parse_args()
EXPORT_DIR = args.export_dir
MODE = args.mode
DEVICE = args.device
EPOCH = args.epoch
BATCH_SIZE = args.batch_size
SEQ_LENGTH = args.seq_length
LEARN_RATE = args.learn_rate
#Preprocess
x, y, info_test = data_manager.preprocess(DATASET_DIR,
BATCH_SIZE,
SEQ_LENGTH,
mode=MODE)
total_batch = float(x.train.shape[0] + x.test.shape[0] + x.valid.shape[0])
print('Data Loaded\n' + 'Train Ratio : ' +
str(round(100 * x.train.shape[0] / total_batch, 2)) +
'%, Test Ratio : ' +
str(round(100 * x.test.shape[0] / total_batch, 2)) +
'%, Valid Ratio : ' +
str(round(100 * x.valid.shape[0] / total_batch, 2)) + '%')
acc_train = np.zeros(EPOCH)
acc_valid = np.zeros(EPOCH)
loss_train = np.zeros(EPOCH)
loss_valid = np.zeros(EPOCH)
#Train
print('\n--------- Training Start ---------')
model = model_archive.CRNN_simple_cnn(x.train.shape[-1], NUM_CLASS)
#model = model_archive.CRNN(16, 1, 25, 64)
#model = torch.load("./export/crnn4/model.pth")
wrapper = Wrapper(model, LEARN_RATE) #(12, 25, 0.0001)
for e in range(EPOCH):
_, acc_train[e], loss_train[e] = wrapper.run_model(
x.train, y.train, DEVICE, 'train')
_, acc_valid[e], loss_valid[e] = wrapper.run_model(
x.valid, y.valid, DEVICE, 'eval')
#if wrapper.early_stop(loss_valid[e]): break
print('Epoch [' + str(e + 1).zfill(3) + '/' + str(EPOCH) + ']' +
' acc : ' + str(round(acc_train[e], 4)) + ' - val_acc : ' +
str(round(acc_valid[e], 4)) + ' | loss : ' +
str(round(loss_train[e], 4)) + ' - val_loss : ' +
str(round(loss_valid[e], 4)))
print('-------- Training Finished -------')
#Test
pred_test, _, _ = wrapper.run_model(x.test, y.test, DEVICE,
'eval') #pred_test: (426848,)
chroma_test = data_manager.batch_dataset(
info_test.chroma, BATCH_SIZE
) #ndarray(songs X num_of_batches_for_each_song, batch_size, seq_len, 12)
chord_test = data_manager.batch_dataset(info_test.chord, BATCH_SIZE)
chroma_test = chroma_test.reshape(
chroma_test.shape[0] * chroma_test.shape[1], chroma_test.shape[-1])
chord_test = chord_test.reshape(chord_test.shape[0] * chord_test.shape[1])
acc_test, pred_test = data_manager.frame_accuracy(chord_test,
pred_test,
mode=MODE)
print('\nTest Accuracy : ' + str(round(100 * acc_test, 2)) + '%')
#Export
wrapper.export(EXPORT_DIR, chroma_test, chord_test, pred_test)
print('Exported files to ' + os.path.abspath(EXPORT_DIR))
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]
features_training_data = [
'open_lastclose_ratio', 'high_close_ratio', 'low_close_ratio',
def main():
#Directory Settings
DATASET_DIR = './dataset/'
EXPORT_DIR = './export/CNN_range/'
#Parameter Settings
MODE = 'beatsync'
DEVICE = 1 # 0 : cpu, 1 : gpu0, 2 : gpu1, ...
NUM_CLASS = 25 # 0 : Silence, 1 - 12: Major, 13 - 24: Minor, Don't change this parameter
EPOCH = 60
BATCH_SIZE = 128
LEARN_RATE = 0.01
SEQ_LENGTH = 10
parser = argparse.ArgumentParser()
parser.add_argument('--export_dir',
type=str,
default=EXPORT_DIR,
help='export directory')
parser.add_argument('--mode',
type=str,
default=MODE,
help='which mode? frame or beatsync')
parser.add_argument('--device',
type=int,
default=DEVICE,
help='which device? 0 : cpu, over 1 : gpu')
parser.add_argument('--epoch',
type=int,
default=EPOCH,
help='how many epoch?')
parser.add_argument('--batch_size',
type=int,
default=BATCH_SIZE,
help='how many batch?')
parser.add_argument('--learn_rate',
type=float,
default=LEARN_RATE,
help='learning rate')
parser.add_argument('--seq_length',
type=int,
default=SEQ_LENGTH,
help='CNN sequence length')
args = parser.parse_args()
EXPORT_DIR = args.export_dir
MODE = args.mode
DEVICE = args.device
EPOCH = args.epoch
BATCH_SIZE = args.batch_size
LEARN_RATE = args.learn_rate
SEQ_LENGTH = args.seq_length
#Preprocess
x, y, info_test = data_manager.preprocess(DATASET_DIR,
BATCH_SIZE,
SEQ_LENGTH,
mode=MODE)
total_batch = float(x.train.shape[0] + x.test.shape[0] + x.valid.shape[0])
print('Data Loaded\n' + 'Train Ratio : ' +
str(round(100 * x.train.shape[0] / total_batch, 2)) +
'%, Test Ratio : ' +
str(round(100 * x.test.shape[0] / total_batch, 2)) +
'%, Valid Ratio : ' +
str(round(100 * x.valid.shape[0] / total_batch, 2)) + '%')
acc_train = np.zeros(EPOCH)
acc_valid = np.zeros(EPOCH)
loss_train = np.zeros(EPOCH)
loss_valid = np.zeros(EPOCH)
#Train
print('\n--------- Training Start ---------')
wrapper = Wrapper(x.train.shape[-1], NUM_CLASS, LEARN_RATE)
#wrapper.model.cuda(device=DEVICE-1)
# x = minibatch x batchsize x chroma // y = minibatch x batchsize
for e in range(EPOCH):
shuff_train = np.arange(x.train.shape[0])
np.random.shuffle(shuff_train)
shuff_valid = np.arange(x.valid.shape[0])
np.random.shuffle(shuff_valid)
_, acc_train[e], loss_train[e] = wrapper.run_model(
x.train[shuff_train], y.train[shuff_train], DEVICE, 'train')
_, acc_valid[e], loss_valid[e] = wrapper.run_model(
x.valid[shuff_valid], y.valid[shuff_valid], DEVICE, 'eval')
#_, acc_train[e], loss_train[e] = wrapper.run_model(x.train, y.train, DEVICE, 'train')
#_, acc_valid[e], loss_valid[e] = wrapper.run_model(x.valid, y.valid, DEVICE, 'eval')
if wrapper.early_stop(loss_valid[e]): break
print('Epoch [' + str(e + 1).zfill(3) + '/' + str(EPOCH) + ']' +
' acc : ' + str(round(acc_train[e], 4)) + ' - val_acc : ' +
str(round(acc_valid[e], 4)) + ' | loss : ' +
str(round(loss_train[e], 4)) + ' - val_loss : ' +
str(round(loss_valid[e], 4)))
print('-------- Training Finished -------')
#Test
pred_test, _, _ = wrapper.run_model(x.test, y.test, DEVICE, 'eval')
chroma_test = data_manager.batch_dataset(info_test.chroma, BATCH_SIZE)
chord_test = data_manager.batch_dataset(info_test.chord, BATCH_SIZE)
chroma_test = chroma_test.reshape(
chroma_test.shape[0] * chroma_test.shape[1], chroma_test.shape[-1])
chord_test = chord_test.reshape(chord_test.shape[0] * chord_test.shape[1])
acc_test, pred_test = data_manager.frame_accuracy(chord_test,
pred_test,
info_test,
BATCH_SIZE,
mode=MODE)
print('\nTest Accuracy : ' + str(round(100 * acc_test, 2)) + '%')
# Export
wrapper.export(EXPORT_DIR, chroma_test, chord_test, pred_test, acc_test)
print('Exported files to ' + os.path.abspath(EXPORT_DIR))
def learnFunc(self):
if self.code is None or self.df is None:
return
self.change_value.emit(ZERO)
# 데이터 전처리
code = self.code
chart_data = self.df
prep_data = data_manager.preprocess(chart_data)
training_data = data_manager.build_training_data(prep_data)
training_data = training_data.dropna()
# 차트데이터 분리
feature_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[feature_chart_data]
# emit
self.change_value.emit(TWENTY_FIVE)
# 학습데이터 분리
feature_chart_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[feature_chart_data]
# 정책 신경망을 파일로 저장
self.createFolder('model')
mdir = os.path.join(settings.BASE_DIR, 'model')
self.createFolder(os.path.join(mdir, code))
model_dir = os.path.join(mdir, code)
model_path = os.path.join(model_dir, 'model%s.h5' % code)
# model_path 경로가 없으면 학습모델을 해당 dir에 만들어서 학습
# model_path가 있으면 해당 모델 선택 후 예측
print(model_path)
# emit
self.change_value.emit(FIFTY)
if not os.path.isfile(model_path):
start_time = time.time()
policy_learner = PolicyLearner(stock_code=code,
chart_data=chart_data,
training_data=training_data,
fig=self.fig,
canvas=self.canvas,
min_trading_unit=1,
max_trading_unit=2,
delayed_reward_threshold=0.2,
lr=0.001)
policy_learner.fit(balance=10000000,
num_epoches=200,
discount_factor=0,
start_epsilon=0.5)
end_time = time.time()
policy_learner.policy_network.save_model(model_path)
print("LearningTime: {} sec".format(end_time - start_time))
else:
start_time = time.time()
policy_learner = PolicyLearner(stock_code=code,
chart_data=chart_data,
training_data=training_data,
fig=self.fig,
canvas=self.canvas,
min_trading_unit=1,
max_trading_unit=2)
end_time = time.time()
print("LearningTime: {} sec".format(end_time - start_time))
policy_learner.trade(balance=1000000,
model_path=os.path.join(
model_dir, 'model%s.h5' % (code)))
# emit
self.change_value.emit(A_HUNDRED)
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)
# 강화학습에 필요한 주식 데이터 준비
# 1) csv 파일에서 데이터 불러오기
# chart_data = data_manager.load_chart_data_fromCSV(os.path.join(settings.BASE_DIR, 'data/chart_data/{}.csv'.format(stock_code)))
# 2) database에서 데이터 불러오기
chart_data = data_manager.load_chart_data_fromDB(stock_code)
prep_data = data_manager.preprocess(
chart_data) # 불러온 차트데이터 전처리하여 학습 데이터를 만들 준비
training_data = data_manager.build_training_data(
prep_data) # 학습 데이터에 포함될 열들을 추가
# 이 training_data는 차트 데이터의 열들, 전처리에서 추가된 열들, 학습 데이터의 열들이 모두 포함된 데이터이다.
# 기간 필터링
training_data = training_data[(training_data['date'] >= '2017-01-01')
& (training_data['date'] <= '2017-12-31')]
training_data = training_data.dropna()
# 데이터를 강화학습에 필요한 차트 데이터와 학습 데이터로 분리하기 --> 여러 feature를 가진 training_data는 필요한 부분들(DOHLCV의 차트 데이터와 15개의 feature를 가진 학습 데이터)로 떼어낸다.
# 차트 데이터 분리
features_chart_data = ['date', 'open', 'high', 'low', 'close', 'volume']
chart_data = training_data[features_chart_data]
# 학습 데이터 분리
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
from data_manager import load_data, preprocess, get_train_data
from environment import Environment
ticker = 'MSFT'
start_date = '2010-01-01'
df = load_data(ticker, start_date)
df['Date'] = df['Date'].astype('str')
# print(df.head())
predf = preprocess(df)
# print(predf.head())
print(Environment(predf).observe())
print(Environment(predf).get_price())
def main():
#Directory Settings
DATASET_DIR = './dataset/'
EXPORT_DIR = './export/result/'
#Parameter Settings
MODE = 'beatsync'
DEVICE = 1 # 0 : cpu, 1 : gpu0, 2 : gpu1, ...
NUM_CLASS = 25 # 0 : Silence, 1 - 12: Major, 13 - 24: Minor, Don't change this parameter
EPOCH = 100
BATCH_SIZE = 128
LEARN_RATE = 0.001
SEQ_LENGTH = 10
parser = argparse.ArgumentParser()
parser.add_argument('--export_dir',
type=str,
default=EXPORT_DIR,
help='export directory')
parser.add_argument('--mode',
type=str,
default=MODE,
help='which mode? frame or beatsync')
parser.add_argument('--device',
type=int,
default=DEVICE,
help='which device? 0 : cpu, over 1 : gpu')
parser.add_argument('--epoch',
type=int,
default=EPOCH,
help='how many epoch?')
parser.add_argument('--batch_size',
type=int,
default=BATCH_SIZE,
help='how many batch?')
parser.add_argument('--learn_rate',
type=float,
default=LEARN_RATE,
help='learning rate')
parser.add_argument('--seq_length',
type=int,
default=SEQ_LENGTH,
help='CNN sequence length')
args = parser.parse_args()
EXPORT_DIR = args.export_dir
MODE = args.mode
DEVICE = args.device
EPOCH = args.epoch
BATCH_SIZE = args.batch_size
LEARN_RATE = args.learn_rate
SEQ_LENGTH = args.seq_length
#Preprocess
x, y, info_test = data_manager.preprocess(DATASET_DIR,
BATCH_SIZE,
SEQ_LENGTH,
mode=MODE)
total_batch = float(x.train.shape[0] + x.test.shape[0] + x.valid.shape[0])
print('Data Loaded\n' + 'Train Ratio : ' +
str(round(100 * x.train.shape[0] / total_batch, 2)) +
'%, Test Ratio : ' +
str(round(100 * x.test.shape[0] / total_batch, 2)) +
'%, Valid Ratio : ' +
str(round(100 * x.valid.shape[0] / total_batch, 2)) + '%')
#Train
print('\n--------- Training Start ---------')
wrapper = Wrapper(x.train.shape[-1], NUM_CLASS, LEARN_RATE)
#wrapper.model.cuda(device=DEVICE-1)
# x = minibatch x batchsize x chroma // y = minibatch x batchsize
#Load model
model = torch.load('export/model_56.489192.pth')
wrapper.model = model
#Test
pred_test, _, _ = wrapper.run_model(x.test, y.test, DEVICE, 'eval')
chroma_test = data_manager.batch_dataset(info_test.chroma, BATCH_SIZE)
chord_test = data_manager.batch_dataset(info_test.chord, BATCH_SIZE)
chroma_test = chroma_test.reshape(
chroma_test.shape[0] * chroma_test.shape[1], chroma_test.shape[-1])
chord_test = chord_test.reshape(chord_test.shape[0] * chord_test.shape[1])
acc_test, pred_test = data_manager.frame_accuracy(chord_test,
pred_test,
info_test,
BATCH_SIZE,
mode=MODE)
print('\nTest Accuracy : ' + str(round(100 * acc_test, 2)) + '%')
# Export
wrapper.export(EXPORT_DIR, chroma_test, chord_test, pred_test, acc_test)
print('Exported files to ' + os.path.abspath(EXPORT_DIR))