def __init__(self, stock_value, stock_share, traders_init_cash, n_traders):
self.init_stock_value = stock_value
self.stock_share = stock_share
self.trade_volume = 0
self.n_periods = 200
file_path = '/Users/pedrorodriguezflores/Documents/Desarrollo/Data/BMV/AC.MX.csv'
#self.stock = stock.File_Stock(file_path, self.n_periods)
self.stock = stock.Stock(self.init_stock_value, self.stock_share, self.n_periods)
self.n_traders = n_traders
self.market_traders = []
self.test_traders = []
for i in range(self.n_traders):
perfil = [-random.random(), random.random(), random.randint(1,50)]
self.market_traders.append(trader.Fish(traders_init_cash, self.n_periods, perfil))
#for i in range(self.n_traders):
#self.traders.append(trader.Centered(traders_init_cash,self.init_stock_value))
perfil = [-0.3, 0.5, random.randint(1,9)]
self.test_traders.append(trader.Fish(traders_init_cash, self.n_periods, perfil))
#self.test_traders.append(trader.Whale(traders_init_cash, self.n_periods))
#self.test_traders.append(trader.Value(traders_init_cash, self.n_periods, self.init_stock_value))
self.day = self.n_periods
self.days = np.arange(self.day - self.n_periods - 1, self.day, 1)
return None
def test_dongguan_trader(user_name,user_password):
tmp_trader = Trader(Constant.DONGGUAN_IP,
Constant.TRADE_PORT,
user_name,
user_password,
'0',
Constant.DONGGUAN_YYB,
Constant.DLL_PATH,
None,
sh_code='',
sz_code='',
)
user_code = tmp_trader.login()
return user_code
def test_changcheng_trader(user_name,user_password):
tmp_trader = Trader(Constant.CHANGCHENG_IP,
Constant.TRADE_PORT,
user_name,
user_password,
'0',
Constant.CHANGCHENG_YYB,
Constant.DLL_PATH,
None,
sh_code='',
sz_code='',
)
user_code = tmp_trader.login()
return user_code
def test_hengtai_trader(user_name,user_password):
tmp_trader = Trader(Constant.HENGTAI_IP,
Constant.TRADE_PORT,
user_name,
user_password,
'0',
Constant.HENGTAI_YYB,
Constant.DLL_PATH,
None,
sh_code='',
sz_code='',
)
user_code = tmp_trader.login()
return user_code
def test_zhongtou_trader(user_name,user_password):
tmp_trader = Trader(Constant.ZHONGTOU_IP,
Constant.TRADE_PORT,
user_name,
user_password,
'0',
Constant.ZHONGTOU_YYB,
Constant.DLL_PATH,
None,
sh_code='',
sz_code='',
)
user_code = tmp_trader.login()
return user_code
class BackTestor:
def __init__(self, order_path):
self.r = Reader()
self.t = Trader()
self.LoadOrder(order_path)
def LoadOrder(self, order_path):
self.r.load_order_file(order_path)
for i in range(self.r.get_ordersize()):
o = self.r.read_border(i)
if o.price > 0:
self.t.RegisterOneTrade(o.contract, o.size if o.side == 1 else -o.size, o.price)
def Plot(self):
self.t.PlotStratPnl()
def main(self):
[dataMat, labelMat
] = FeatureGenerator.FeatureParser(self.messageBook, self.limitBook,
self.timeFrame,
self.useCachedFiles).parse()
print "Generated Features of size: (%d,%d)" % dataMat.shape
self.labelMat = labelMat
count = 0
self.predictMat = numpy.zeros((labelMat.shape))
for obs in dataMat: #an observation is a row in the dataMat
self.cache.add(obs)
if self.cache.needUpdate():
print "huh"
self.model = self.trainer.train(self.cache.getData())
prediction = self.model.predict(obs)
self.predictMat[count, 0] = prediction
count += 1
if count % 1000 == 0:
print "On Obs: %d" % count
self.trader.trade(Trader.DataPt(obs), prediction)
self.printAnalysis()
def realizationCalculatorCSV():
print("Loading csv file 'sampledata(1).csv data...")
import_file = open("Data/sampledata(1).csv", "r")
export_file = open("Data/exportdataCSV.csv", "w")
t = Trader("badApple")
for line in import_file:
import_string = line.rstrip("\n")
import_list = import_string.split(",")
# updates export_list data by calling t.trade( ) function
export_list = t.trade(import_list)
export_string = ",".join(export_list) + "\n"
# appends data to export_file csv file
export_file.write(export_string)
import_file.close()
export_file.close()
print("Data exported to exportdata(1).csv")
def __init__(self):
self.reader = Reader()
self.order_file_size = 0
self.shot_file_size = 0
self.pos= {}
self.net_pnl = {}
self.gross_pnl = {}
self.ticker_strat_map = {}
self.avgcost = {}
self.gross_time_allpnl_map = {}
self.net_time_allpnl_map = {}
self.strat_data_map = {}
self.gross_strat_pnl_map = {}
self.net_strat_pnl_map = {}
self.pnl_contract = set([])
self.Caler = CALER(contract_config_path)
self.trader = Trader()
def Action_Buy(self):
print("sell")
if self.positions_total >= 1:
return -1
else:
self.position_data = trader.Buy_Action(self.mt, self.symbol)
self.last_action = "long"
return 0.0005
def Action_Sell(self):
print("Buy")
if self.positions_total >= 1:
return -1
else:
self.position_data = trader.Sell_Avtion(self.mt, self.symbol)
self.last_action = "short"
return 0.5
def Action_Close(self):
print("Closing")
if self.positions_total >= 1:
trader.Close_Position(self.mt, self.symbol,
self.position_data["result"],
self.last_action)
return self.account_profit
else:
return -1
def Connect():
'''连接端口'''
global trader, market
trader = Trader.Trader()
market = MarketDataCenter.MarketDataCenter()
res = True
if market.Connect() == False or trader.Connect() == False:
res = False
if res == False:
Release()
return res
def invest(stocks):
totalvalue = 0
for stock in stocks:
trader = Trader.Trader(stock)
print('trading ' + stock)
trader.run_test()
totalvalue = round((totalvalue + trader.total_value), 2)
print('\n\rYou have made £{} in profit'.format(
round(totalvalue - (len(stocks) * 1000)), 5))
def realizationCalculator():
print("Loading xlsx file 'sampledata.xlsx' data...")
workbook = openpyxl.load_workbook('Data/sampledata.xlsx')
worksheet = workbook.active
export_workbook = openpyxl.Workbook()
export_worksheet = export_workbook.active
dest_filename = "Data/exportdataXLSX.xlsx"
t = Trader("badApple")
for row in worksheet.iter_rows(min_row=1):
# parses data from row
date = row[0].value
date_and_time = row[1].value
action = row[2].value
symbol = row[3].value
quantity = row[4].value
price = row[5].value
data = [date, date_and_time, action, symbol, quantity, price]
# updates export_list data by calling t.trade( ) function
export_list = t.trade(data)
# appends data to export openpyxl worksheet
export_worksheet.append(export_list)
# saves export_workbook to 'exportdata.xlsx'
export_workbook.save(dest_filename)
print("Saved processed data in ", dest_filename)
def GenBTReport(bt_file_path, file_name='strat_pnl_hist'):
r = Reader()
t = Trader()
r.load_order_file(bt_file_path)
for i in range(r.get_ordersize()):
o = r.read_border(i)
if o.price > 0 and abs(o.size) > 0:
t.RegisterOneTrade(o.ticker, o.size if o.side == 1 else -o.size,
o.price)
t.PlotStratPnl(file_name)
return t.GenDFReport(), t.GenStratReport()
def day_simulations(clf_acc, daytrader, debug=True):
clf, trainingAcc = clf_acc
correct = 0
total = 0
y_true, y_pred = daytrader.test_ys, clf.predict(daytrader.test_xs)
accuracy = Trader.reports(y_true, y_pred, debug=debug)
money = 1.0
for i in range(len(daytrader.test_xs)):
gain = daytrader.testingGains[i]
prediction = clf.predict([daytrader.test_xs[i]])
if prediction == 1:
money += gain
else:
money -= gain
# print "money is ", money
# print "num trials", len(daytrader.testingGains)
return accuracy, money
def __init__(self): """ Inicializuje moduly k rozhodnutí o nákupu či prodeji, a simulaci, či ostré obchodování. :return: """ self.config = Helper.Config() self.logger = Logger.TraderLogging() self.simmode = self.config.simMode self.tradedecisions = ProceedAlgorythms.AllDecisionsAndStrategies() self.fetch = FetchDataForDecisions() self.tradingpairs = self.fetch.pairsFromDatabase() # self.realtimepricepolicy = PricePolicy.RealtimePricePolicy() self.boughts = [] if self.simmode: import Simulation self.trade = Simulation.Trade() else: import Trader self.trade = Trader.Trade()
def TradeReport(date_prefix, trade_path, cancel_path, file_name=''):
trader = Trader()
command = 'cat ' + date_prefix + 'log/order.log | grep Filled > ' + trade_path + '; cat ' + date_prefix + 'log/order_night.log | grep Filled >> ' + trade_path
command_result = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
command = 'cat ' + date_prefix + 'log/order.log | grep Cancelled > ' + cancel_path + '; cat ' + date_prefix + 'log/order_night.log | grep Cancelled >> ' + cancel_path
command_result = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
time.sleep(3)
trade_details = []
with open(trade_path) as f:
ei = ExchangeInfo()
for l in f:
temp = []
ei.construct(l)
temp.append(
datetime.datetime.fromtimestamp(float(
ei.time_str)).strftime("%Y-%m-%d %H:%M:%S"))
temp.append(ei.ticker)
temp.append("Buy" if ei.side == 0 else "Sell")
temp.append(ei.trade_price)
temp.append(ei.trade_size)
trade_details.append(temp)
trader.RegisterOneTrade(
ei.ticker,
int(ei.trade_size) if ei.side == 0 else -int(ei.trade_size),
float(ei.trade_price))
#print('printint')
df = trader.GenDFReport()
trader.PlotStratPnl(file_name=file_name)
#print(df)
#trader.Summary()
df.insert(len(df.columns), 'cancelled', 0)
with open(cancel_path) as f:
ei = ExchangeInfo()
for l in f:
ei.construct(l)
if ei.ticker not in df.index:
df.loc[ei.ticker] = 0
df.loc[ei.ticker, 'cancelled'] = df.loc[ei.ticker, 'cancelled'] + 1
return df, trader.GenStratReport(), pd.DataFrame(
trade_details, columns=['time', 'ticker', 'Side', 'price', 'size'])
def main():
"""Initializes the application
"""
run = Trader.run()
# Load settings and create the config object
config = Configuration()
settings = config.settings
# Set up logger
logs.configure_logging(settings['log_level'], settings['log_mode'])
logger = structlog.get_logger()
# Configure and run configured behaviour.
exchange_interface = ExchangeInterface(config.exchanges)
notifier = Notifier(config.notifiers)
behaviour = Behaviour(config, exchange_interface, notifier)
while True:
behaviour.run(settings['market_pairs'], settings['output_mode'])
logger.info("Sleeping for %s seconds", settings['update_interval'])
time.sleep(settings['update_interval'])
def __init__(self, messageBook, limitBook, modelType):
self.messageBook = messageBook
self.limitBook = limitBook
self.dataMat = None
self.labelMat = None #note this is ground truth, will not be known to the trainer/model until X timesteps ahead
self.predictMat = None
self.timeFrame = 4000
self.neutralQueueSize = 4000
self.upQueueSize = 4000
self.downQueueSize = 4000
self.retrainCount = 1000
self.price = 1000000
self.useCachedFiles = False
self.cache = Cache.Cache(self.neutralQueueSize, self.upQueueSize,
self.downQueueSize, self.timeFrame,
self.retrainCount)
self.model = Model.Model(None, None, None)
self.modelType = modelType
self.trainer = Trainer.Trainer(self.modelType)
self.trader = Trader.Trader(self.price, self.timeFrame)
self.start_time = time.time()
def login_zhongtou_trader(user_name, user_password, user_id):
try:
tmp_trader = Trader(
Constant.ZHONGTOU_IP,
Constant.TRADE_PORT,
user_name,
user_password,
'0',
Constant.ZHONGTOU_YYB,
Constant.DLL_PATH,
None,
sh_code='',
sz_code='',
)
if not tmp_trader.login():
return 2 #代表错误信息无法登陆
tmp_trader.query_positions(Constant.QUERY_STOCKS)
stock_input = tmp_trader.trader_Ree.value.decode('gbk',
'ignore').split('|')
tmp_trader.query_positions(Constant.QUERY_PROPERTY)
property_input = tmp_trader.trader_Ree.value.decode(
'gbk', 'ignore').split('|')
tmp_trader.query_positions(Constant.QUERY_BOOK)
entrust_input = tmp_trader.trader_Ree.value.decode('gbk',
'ignore').split('|')
tmp_trader.query_positions(Constant.QUERY_FINISH_BOOK)
finish_book_input = tmp_trader.trader_Ree.value.decode(
'gbk', 'ignore').split('|')
zhongtou_stock_info = ZhongTouStockInfo(stock_input, property_input,
entrust_input,
finish_book_input, user_name,
user_id)
zhongtou_stock_info.update_stock_info()
return 1 # 代表执行成功
except Exception as e:
return 3 # 代表错误代码块执行
from Trader import * #Custom settings LOOP_DURATION = 15 * 60 # Time period (in seconds) MAX_LOOP_TIME = 10 * 24 * 60 * 60 # Max duration to run (in seconds) QUOTE_CURRENCY = "BCH" # Cryptocurrency of choice BASE_CURRENCY = "USD" # Fiat currency of choice CSV_PRICE = "price.csv" # Price CSV name CSV_TRANSACTIONS = "transactions.csv" # Transaction CSV name MODE = 2 # Mode of the Bot #Start thread stopFlag = Event() thread = Trader(stopFlag, LOOP_DURATION, QUOTE_CURRENCY, BASE_CURRENCY, CSV_PRICE, CSV_TRANSACTIONS, MODE) thread.daemon = True thread.start() #Set max time to run time.sleep(MAX_LOOP_TIME) stopFlag.set()
def __init__(self, order_path): self.r = Reader() self.t = Trader() self.LoadOrder(order_path)
#plt.ylabel('NT')
#plt.show()
plt.hist(ENV.STATS['DUR'])
plt.ylabel('Duration')
plt.show()
#
# Main
# -------------------------------------------------------------------------------------------------
if __name__ == "__main__":
data_obj = data_loader("save_file")
SPACE = core.Space(data_obj)
BROKER = Trader.Trade()
ENV = core.Env(SPACE, BROKER)
ENV_NAME = 'Trade_rl-v1'
# action space
nb_actions = len(ENV.action_space)
dataset_len = data_obj.length
features = SPACE.features
obs_length = ENV.look_ahead
print("nb_actions", nb_actions)
print("obs shape:", ENV.observation_space.shape[0])
# keras memory
# DDPG
memory = SequentialMemory(limit=500000, window_length=1)
def swing_simulation_for_2018(clf=None, past_days=5, candles=None):
"""
How much money would the swing classifier make in 2018, trained only on 1950-2017?
I'll buy at the close and sell at open on what i think are GREEN days,
and short at close on what I think will be RED days.
returns (accuracy, money)
"""
money = 1 # 1 dollar
candles2018 = candles
if clf == None:
s = SwingTrader(past_days=past_days,
excluding_last=252) # doesnt include last year at all
candles2018 = s.last_remaining()
clf = s.boost()[0]
print "************************no clf!!!!!!"
correct = 0
total = 0
y_true = []
y_pred = []
for candleIndex in range(past_days - 1, len(candles2018) - 1):
past_X_candles = candles2018[candleIndex - past_days + 1:candleIndex +
1]
# THIS IS JUST CLOSE
past_X_days = [[candle.close for candle in past_X_candles]]
# THIS IS OPEN, CLOSE, HIGH, LOW only for GSPC!!!!!!!
# past_X_days = [[candle.open, candle.high, candle.low, candle.close] for candle in past_X_candles]
first_day = float(past_X_days[0][0]) # for normalization
normalized_xs = [[x / first_day for x in y] for y in past_X_days]
# print past_X_days
# print first_day
# print normalized_xs
# print "candles2018[0:10]", [x.close for x in candles2018[:10]]
#
# print "candleIndex", candleIndex
#
#
#
# print "pastXDays", past_X_days
print normalized_xs
prediction = int(
clf.predict(normalized_xs)[0]) # 1 is predicting Green, -1 is Red
tmmrw_open = candles2018[candleIndex + 1].open
today_close = candles2018[candleIndex].close
actual = 1 if tmmrw_open > today_close else -1
y_pred.append(prediction)
y_true.append(actual)
diff = abs(tmmrw_open - today_close) / first_day
# ONLY LONG STRATEGY
if prediction == 1 and actual == 1:
money += diff
elif prediction == 1 and actual == 0:
money -= diff
if actual == prediction: correct += 1
# LONG AND SHORT STRATEGY
# if actual == prediction:
# money += diff
# correct += 1
# else:
# money -= diff
total += 1
_ = Trader.reports(y_true, y_pred)
if total > 0:
accuracy = correct / float(total)
print "Accuracy was {}".format(accuracy)
print "money went from 1.00 to ", money
return accuracy, money
else:
print "less than zero"
return 0, 0
def __init__(self):
self.agent = Agent(hist_ws=hist_ws, forward_ws=forward_ws)
self.trader = Trader(record=True)
self.fee_rate = 0.0001
def __init__(self):
self.f_value = []
self.tr = Trader()
class BaseFactor:
def __init__(self):
self.f_value = []
self.tr = Trader()
def run(self, start_date, end_date, ticker):
self.m = self.LoadData(start_date, end_date, ticker)
self.CalFactor()
self.PlotFactor()
self.TestPnl()
self.PlotSignal()
def PlotSignal(self):
df_list = [i[1] for i in sorted(self.m.items(), key=lambda x: x[0])]
if len(df_list) < 1:
print('empty df')
return
df = df_list[0]
start = time.time()
for i in range(1, len(df_list)):
df = pd.merge(df, df_list[i], how='outer')
print('finished merge used %lfs' % (time.time() - start))
plt.plot(df['mid'], label='mid', alpha=0.3)
buy_x = df[df['money'] < 0].index.tolist()
buy = df[df['money'] < -0.1]
plt.scatter(x=buy.index.tolist(),
y=buy['mid'].tolist(),
marker='.',
s=[4] * len(buy),
c='red',
label='buy')
sell = df[df['money'] > 0.1]
plt.scatter(x=sell.index.tolist(),
y=sell['mid'].tolist(),
marker='.',
s=[4] * len(sell),
c='green',
label='sell')
plt.title('factor percentile signal')
plt.legend()
plt.grid()
plt.show()
def TestPnl(self):
for k in self.m:
df = self.m[k]
up = df['factor'].quantile(0.999)
down = df['factor'].quantile(0.001)
df['money'] = np.where(df['factor'] > up, df['mid'], 0.0)
df['money'] = np.where(df['factor'] < down, -df['mid'],
df['money'])
for i in df['money'].tolist():
if abs(i) > 1:
self.tr.RegisterOneTrade('ni8888', 1 if i > 0 else -1,
abs(i))
self.tr.Summary()
self.tr.PlotStratRawPnl(show=True)
self.tr.PlotStratPnl(show=True)
def PlotFactor(self):
plt.plot(self.f_value, label='factor value')
plt.title('factor value curve')
plt.legend()
plt.grid()
plt.show()
def CalFactor(self):
for k in sorted(self.m.keys()):
df = self.m[k]
df['factor'] = self.cal(df)
self.f_value += df['factor'].tolist()
@abstractmethod
def cal(self, df):
pass
def LoadData(self, start_date, end_date, ticker):
dl = dateRange(start_date, end_date)
m = {}
for date in dl:
path = '/root/' + date + '/' + ticker + '.csv'
if os.path.exists(path):
m[date] = self.ReadData(date, ticker)
else:
print("%s not existed!" % (path))
return m
def ReadData(self, date, ticker):
path = '/root/' + date + '/' + ticker + '.csv'
df = pd.read_csv(path, header=None)
df.columns = shot.get_columns()
df['mid'] = (df['asks[0]'] + df['bids[0]']) / 2
df['return1'] = df['mid'].diff(1).fillna(0.0) / df['mid']
return df
import DataRetriever as dr
import Trader as tr
if __name__ == '__main__':
# api token 股票代码 起始日期 结束日期 数据存储名
data_retriever = dr.DataRetriever(
token='efb2687234ab87799580e022f544e5f28da8c17be5152b8c6819784a',
code='600519.SH',
start='20180101',
end='20210403',
file_name='MaoTai.json')
data_retriever.create_json_file()
# 读取json文件名 初始资本 股票名称
trader = tr.Trader('MaoTai.json', 10000000.0, '贵州茅台')
trader.trade()