def __init__(self, options, config):
"""Initializes all of the submodules bitHopper uses"""
#Logging
logging.basicConfig(stream=sys.stdout, format="%(asctime)s|%(module)s: %(message)s", datefmt="%H:%M:%S", level = logging.INFO)
self.options = options
self.config = config
altercoins = ConfigParser.ConfigParser()
altercoins.read(os.path.join(sys.path[0], "whatevercoin.cfg"))
self.altercoins = {}
for coin in altercoins.sections():
self.altercoins[coin] = dict(altercoins.items(coin))
self.altercoins[coin]['recent_difficulty'] = float(self.altercoins[coin]['recent_difficulty'])
self.scheduler = None
self.lp_callback = lp_callback.LP_Callback(self)
self.difficulty = diff.Difficulty(self)
self.exchange = exchange.Exchange(self)
self.pool = None
self.db = database.Database(self)
self.pool = pool.Pool_Parse(self)
self.api = api.API(self)
self.pool.setup(self)
self.work = work.Work(self)
self.speed = speed.Speed()
self.getwork_store = getwork_store.Getwork_store(self)
self.data = data.Data(self)
self.lp = lp.LongPoll(self)
self.auth = None
self.website = website.bitSite(self)
self.pile = greenpool.GreenPool()
self.plugin = plugin.Plugin(self)
self.pile.spawn_n(self.delag_server)
def main():
e = exchange.Exchange('../lib/binance.db')
start = int(datetime.datetime(2018, 4, 1).timestamp() * 1000)
end = int(datetime.datetime(2018, 7, 1).timestamp() * 1000)
print('loading orders')
number_of_orders = e.get_total_orders_ts('BTCUSDT', 24 * 60 * 60 * 1000, start, end)
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
print('calculating components')
components = generate_components(buy_orders, 10)
fig, axs = plt.subplots(len(components), sharex=True)
for i, c in enumerate(components):
axs[i].plot(c)
plt.show()
def main():
data = pd.read_csv('parameters.csv', header=None)
start = datetime.datetime.strptime(data[0].iloc[0], '%Y-%m-%d %H:%M:%S')
end = datetime.datetime.strptime(
data[0].iloc[-1], '%Y-%m-%d %H:%M:%S') + datetime.timedelta(days=1)
distance_to_ma = []
step = 24
e = exchange.Exchange('../lib/binance.db')
days = (end - start).days
for i in range((end - start).days):
print(i, '/', days)
it = e.get_orders(
'BTCUSDT',
start.timestamp() * 1000 + i * step * 1000 * 60 * 60,
start.timestamp() * 1000 + (i + 1) * step * 1000 * 60 * 60)
current_prices = []
for order in it:
current_prices.append(order.average_price)
distance_to_ma.append(
np.mean(
np.abs(current_prices)[50 - 1:] -
moving_average(current_prices, 50)))
plt.scatter(distance_to_ma, data[2])
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
start = int(datetime.datetime(2018, 4, 1).timestamp() * 1000)
end = int(datetime.datetime(2018, 5, 1).timestamp() * 1000)
print('Loading order data...')
number_of_orders = e.get_total_orders_ts('BTCUSDT', 10 * 1000, start, end)
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
print('Calculating IMFs')
emd = EMD()
IMFs = emd(buy_orders)
N = IMFs.shape[0] + 1
fig, axs = plt.subplots(N, sharex=True)
for i, imf in enumerate(IMFs):
axs[i].plot(imf)
if i > 5:
break
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
start = datetime.datetime(2018, 8, 1)
end = datetime.datetime(2019, 8, 1)
params = parameter_estimation.calculate_parameters(start, end, 6, e)
eemd = EEMD()
emd = eemd.EMD
eIMFs_rate = eemd.eemd(np.array([p[1] for p in params]))
fig, axs = plt.subplots(eIMFs_rate.shape[0],
figsize=(12, eIMFs_rate.shape[0] * 3))
rate = np.zeros(eIMFs_rate.shape[1])
for ax, IMF in zip(axs, eIMFs_rate):
#ax.plot(IMF)
ax.plot(IMF)
analytic_signal = hilbert(IMF)
phase = np.unwrap(np.angle(analytic_signal))
freq = np.diff(phase) / (2 * np.pi * 0.25)
print(np.mean(1 / freq))
plt.tight_layout()
plt.show()
def execute(s):
x = ex.Exchange()
action = s['action']
position = x.get_position()
is_open = (position == 'Buy' or position == 'Sell' and p.short)
# Cancel all open orders
x.cancel_orders()
# Close position if new trade
if is_open and action != position:
res = x.close_position(position)
send_results(x, res, 'Closed '+position+' Position')
is_open = False
# TODO: Open position with SL/TP and no wait
# TODO: Handle partly open position
if not is_open and (action == 'Buy' or action == 'Sell' and p.short):
res = x.open_position(action)
send_results(x, res, 'Opened '+action+' Position')
is_open = True
""" SL/TP can only be set AFTER order is executed if margin is not used """
if is_open and (action == 'Buy' and p.buy_sl or p.short and action == 'Sell' and p.sell_sl):
res = x.stop_loss(action, s['sl_price'])
send(res, True)
if is_open and (action == 'Buy' and p.buy_tp or p.short and action == 'Sell' and p.sell_tp):
res = x.take_profit(action, s['tp_price'])
send(res, True)
# Breakout Order
if p.breakout and action == 'Sell':
x.open_position('Buy', ordertype='stop-loss', price=s['sl_price'], wait=False)
send('Breakout SL set at '+str(s['sl_price']), True)
def main():
#load data
e = exchange.Exchange('../lib/binance.db')
start = int(datetime.datetime(2018, 7, 1).timestamp() * 1000)
#end = int(datetime.datetime(2018, 8, 1).timestamp() * 1000)
end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000)
print('Loading order data...')
number_of_orders, prices = e.get_total_orders_ts('BTCUSDT',
24 * 60 * 60 * 1000,
start, end) #hourly data
print('done')
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
t = [i for i, o in enumerate(buy_orders)]
eemd = EEMD()
emd = eemd.EMD
eIMFs_buys = eemd.eemd(buy_orders)
eIMFs_sells = eemd.eemd(sell_orders)
if eIMFs_buys.shape[0] != eIMFs_sells.shape[0]:
print('size mismatch')
n = min(eIMFs_buys.shape[0], eIMFs_sells.shape[0])
fig, axs = plt.subplots(3, figsize=(12, 9), sharex=True)
axs[0].plot(prices)
axs[0].set_ylabel('Price')
buys = np.sum(eIMFs_buys[1:-2], axis=0)
sells = np.sum(eIMFs_sells[1:-2], axis=0)
axs[1].plot(buys, color='g')
axs[1].plot(sells, color='r')
axs[2].plot(calculate_returns(prices), color='b')
ax3 = axs[2].twinx()
ax3.plot((0, len(prices)), (0.5, 0.5))
ax3.plot(buys - sells)
plt.xlabel("Time /days")
#plt.tight_layout()
plt.show()
def setup():
key_file = "../jsons/keys.json"
user_file = "../jsons/users.json"
balance_file = "../jsons/exchange_balance.json"
user = "******"
user_data = ex.get_user_info(user_file, user)
shrimp_keys = ex.get_shrimpy_keys(key_file)
EXCHANGE = ex.Exchange(shrimp_keys, user_data)
EXCHANGE.get_balance()
EXCHANGE.save_balance(balance_file)
EXCHANGE.print_useful_info()
return EXCHANGE
def main():
#load data
e = exchange.Exchange('../lib/binance.db')
start = int(datetime.datetime(2018, 7, 1).timestamp() * 1000)
end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000)
print('Loading order data...')
number_of_orders, prices = e.get_total_orders_ts('BTCUSDT', 60 * 60 * 1000, start, end) #hourly data
print('done')
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
t = [i for i, o in enumerate(buy_orders)]
eemd = EEMD()
emd = eemd.EMD
eIMFs = eemd.eemd(buy_orders - sell_orders)
n = eIMFs.shape[0]
fig, axs = plt.subplots(n + 3, figsize=(12,9), sharex=True)
axs[0].plot(prices)
axs[0].set_ylabel('Price')
axs[1].plot(buy_orders - sell_orders, color='g')
axs[1].set_ylabel('Orders - (Buy - sell)')
axs[2].plot(calculate_returns(prices))
for i in range(n):
axs[i + 3].plot(eIMFs[i], color='g')
axs[i + 3].set_ylabel('eIMF ' + str(i + 1))
plt.xlabel("Time /days")
#plt.tight_layout()
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
times = [datetime.datetime(2018, 4, 1) + datetime.timedelta(days=i) for i in range(500)]
start = datetime.datetime(2019, 4, 2)
end = datetime.datetime(2019, 4, 28)
EMA = []
alpha = 0.3
returns = []
previous_price = None
it = e.get_orders('BTCUSDT', start.timestamp() * 1000, end.timestamp() * 1000)
for order in it:
if previous_price is None:
previous_price = order.end_price
continue
elif np.abs(np.log(previous_price / order.end_price)) < 10 **-5:
continue
if len(EMA) == 0:
EMA.append(np.log(order.end_price / previous_price))
else:
EMA.append(alpha * np.log(order.end_price / previous_price) + (1 - alpha) * EMA[-1])
r = order.end_price / previous_price
previous_price = order.end_price
returns.append(np.log(r))
r_var = np.var(returns)
e_var = np.var(EMA)
#limits = [[-3 * np.sqrt(e_var), 3 * np.sqrt(e_var)], [-3 * np.sqrt(r_var), 3 * np.sqrt(r_var)]]
limits = [[-0.0003, 0.0003], [-0.001, 0.001]]
plt.hist2d(EMA[:-1], returns[1:], bins = 1000, range=limits)
plt.ylabel('Next return')
plt.xlabel('Return EMA')
plt.show()
def main():
#load data
e = exchange.Exchange('../../lib/binance.db')
start = int(datetime.datetime(2018, 4, 1).timestamp() * 1000)
end = int(datetime.datetime(2019, 5, 1).timestamp() * 1000)
#end = int(datetime.datetime(2018, 5, 1).timestamp() * 1000)
print('Loading order data...')
number_of_orders, prices = e.get_total_orders_ts('BTCUSDT',
60 * 60 * 1000 * 6, start,
end) #hourly data
print('done')
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
buy_orders[buy_orders <= 0] = np.mean(buy_orders)
sell_orders[sell_orders <= 0] = np.mean(sell_orders)
returns = np.array(calculate_returns(prices))
returns_decomp = decompose(returns, period=24 * 7)
sa_returns = returns_decomp.trend + returns_decomp.resid
buy_orders_decomp = decompose(buy_orders, period=24 * 7)
sa_buy_orders = buy_orders_decomp.trend + buy_orders_decomp.resid
sell_orders_decomp = decompose(sell_orders, period=24 * 7)
sa_sell_orders = sell_orders_decomp.trend + sell_orders_decomp.resid
x, corrs = get_correlation_coef(
buy_orders_decomp.resid - sell_orders_decomp.resid,
returns_decomp.resid, 28, False)
plt.bar(x, corrs)
plt.show()
def __init__(self, mktList, commModel, slipModel, initCash):
self._mktList = mktList
self._comm = commModel
self._slip = slipModel
# barDict = {}
# for mkt in mktList:
# barDict[mkt.instrument] = marketdata.from_mktdata_to_bar(
# mkt.mktDataGenerator.next(), mkt.freq)
self._barDictGenerator = marketdata.MergedBarDictGenerator(mktList)
barDict = self._barDictGenerator.next()
self._barGroup = bar.BarGroup(barDict)
self._exchange = exchange.Exchange(self._barGroup, slipModel, commModel)
self._account = account.Account(initCash, self._exchange)
self._hist = self._exchange._hist
self._barGroup.updateEvent.subscribe(self._onMktData)
self._barGroup.updateEvent.subscribe(self._hist._onMktData)
self._position = self._account._position
def load_coinbase():
ed = exchange.Exchange('coinbase.db')
years = [i for i in range(2015, 2019)]
csvs = []
for year in years:
csvs.extend(['../Download/Coinbase/' + str(year) + '/' + str(i) + '/BTC-USD.csv' for i in range(1, 13)])
csvs.extend(['../Download/Coinbase/' + '2019/' + str(i) + '/BTC-USD.csv' for i in range(1, 8)])
for csv in csvs:
print(csv)
df = pd.read_csv(csv)
df['time'] = pd.to_datetime(df['time']).astype(int) / (10 ** 6)
m = {'sell': False, 'buy': True}
df['side'] = df['side'].map(m)
df.columns = ['timestamp', 'trade_id', 'price', 'volume', 'maker']
ed.write_transaction_dataframe('BTCUSDT', df)
def main():
e = exchange.Exchange('../lib/binance.db')
start = datetime.datetime(2018, 4, 1)
end = datetime.datetime(2019, 8, 1)
params = calculate_parameters(start, end, 24, e)
print(np.mean(params, axis=0), np.var(params, axis=0))
#plt.plot([p[0] for p in params])
fig, ax = plt.subplots(1)
with open('parameters.csv', 'w') as csvfile:
writer = csv.writer(csvfile)
for p in params:
writer.writerow([start] + p)
start = start + datetime.timedelta(days=1)
ax2 = ax.twinx()
ax.plot([p[0] for p in params])
ax2.plot([p[1] for p in params], color='orange')
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
times = [
datetime.datetime(2018, 4, 1) + datetime.timedelta(days=i)
for i in range(500)
]
p_00 = []
p_11 = []
prices = []
for start, end in zip(times[:-1], times[1:]):
print(start)
it = e.get_orders('BTCUSDT',
start.timestamp() * 1000,
end.timestamp() * 1000)
trade_data = {'price': [], 'time': [], 'side': []}
for order in it:
trade_data['price'].append(order.end_price)
trade_data['time'].append(order.time)
trade_data['side'].append(
order.buyer) #True if market order is a buy
trade_data = pd.DataFrame(trade_data)
trade_data['price_change'] = np.log(
np.concatenate(([1], trade_data['price'].values[1:] /
trade_data['price'].values[:-1])))
movement = np.zeros(trade_data.shape[0])
movement[trade_data['price_change'] > 0] = 1
movement[trade_data['price_change'] < 0] = -1
chain = movement[movement != 0]
P, states = transition_probabilities(chain)
try:
p_11.append(P[states[1]][states[1]])
p_00.append(P[states[-1]][states[-1]])
except:
pass
prices.append(np.mean(trade_data['price']))
#fig, ax1 = plt.subplots()
#ax2 = ax1.twinx()
#ax1.plot(prices, color='blue')
#ax2.plot(p_11, color='green', label='p_11')
#ax2.plot(p_00, color='red', label='p_00')
#ax2.legend()
#ax1.set_xlabel('Day')
#ax1.set_ylabel('BTC Price')
#ax2.set_ylabel('Probability')
plt.figure()
plt.hist(np.diff(p_00), 50, density=True)
loc, scale = norm.fit(np.diff(p_00))
x = np.linspace(np.min(np.diff(p_00)), np.max(np.diff(p_00)), 100)
plt.plot(x, norm.pdf(x, loc=loc, scale=scale))
plt.figure()
plt.hist(np.diff(p_11), 50, density=True)
x = np.linspace(np.min(np.diff(p_11)), np.max(np.diff(p_11)), 100)
loc, scale = norm.fit(np.diff(p_11))
plt.plot(x, norm.pdf(x, loc=loc, scale=scale))
plt.show()
import exchange as ex
import time
# First Pass
def make_trade(exchange, fromSymbol, toSymbol, amt_from):
cont = exchange.check_conversion(fromSymbol, toSymbol)
cont = True
if cont:
print("Trading Pair Exists!")
exchange.create_trade(fromSymbol, toSymbol, amt_from)
#exchange.current_trades
while (len(exchange.current_trades) > 0):
print(exchange.check_trades())
time.sleep(6)
else:
print("Pair Doesn't Exist")
return False
if __name__ == '__main__':
key_file = "../jsons/keys.json"
user_file = "../jsons/users.json"
user = "******"
user_data = ex.get_user_info(user_file, user)
shrimp_keys = ex.get_shrimpy_keys(key_file)
exchange = ex.Exchange(shrimp_keys, user_data)
exchange.print_useful_info()
#make_trade(exchange,"USD","XBT", 5.00)
def greatdeluge2opt(self, arg_timetable, arg_teacher):
# 初期化 cnt_stag:停滞回数 penalty_history:解の記録
cnt_stag = 0
penalty_history = []
# オブジェクト生成
obj1 = exchange.Exchange()
obj2 = penalty.Penalty()
obj3 = arrangement.Arrangement()
# 先生配置
teacher = copy.deepcopy(arg_teacher)
obj3.arrange_teacher(arg_timetable, teacher)
# ペナルティ計算
cost_current = obj2.calc_penalty_soft(arg_timetable, teacher)
# 最小ペナルティ
min_cost = cost_current
# 初期水位
water_level = cost_current
# ペナルティ記録
penalty_history.append(cost_current)
# ループ
while min_cost > 0 and cnt_stag < MAX_STAG1:
### 2-opt ###
# コピー
timetable = copy.deepcopy(arg_timetable)
teacher = copy.deepcopy(arg_teacher)
# 交換
obj1.exchange3(timetable)
# 先生配置
obj3.arrange_teacher(timetable, teacher)
# 現在のペナルティ
cost_neigh = obj2.calc_penalty_soft(timetable, teacher)
# 改善 or 水位以下
if cost_current >= cost_neigh or water_level >= cost_neigh:
# 交換を許可
arg_timetable = copy.deepcopy(timetable)
cost_current = cost_neigh
# 改善
if cost_current < min_cost:
# ペナルティ
min_cost = cost_current
min_timetable = copy.deepcopy(arg_timetable)
cnt_stag = 0
# 水位以下
if cost_current < water_level:
# 水位を下げる
water_level -= DEC_WATER1
# 同じ
if cost_current == min_cost or cost_current == water_level:
cnt_stag += 1
else:
cnt_stag += 1
# 再上昇
if cnt_stag % FREQ_RERISE1 == 0:
water_level += RERISE1
# 表示
print('min_pena', min_cost)
print('cur_pena', cost_current)
print('water_level', water_level)
print('cnt_stag', cnt_stag)
print()
# ペナルティ記録
penalty_history.append(cost_current)
obj3.arrange_teacher(min_timetable, arg_teacher)
return arg_timetable, teacher, min_cost, penalty_history
def main():
e = exchange.Exchange('../lib/binance.db')
start = datetime.datetime(2018, 4, 1)
days = [start + datetime.timedelta(days=i) for i in range(400)]
daily_returns = []
daily_increases = []
daily_decreases = []
daily_price = []
rates = []
p_00 = []
p_11 = []
EMA = []
alpha = 2 / (50 + 1)
price = None
for start, end in zip(days[:-1], days[1:]):
print(start)
it = e.get_orders('BTCUSDT',
start.timestamp() * 1000,
end.timestamp() * 1000)
trade_data = {'price': [], 'time': [], 'side': []}
returns = []
prices = []
increases = []
decreases = []
for order in it:
if price is None:
r = 1
price = order.end_price
continue
elif price != order.end_price:
r = order.end_price / price
else:
continue
trade_data['price'].append(order.end_price)
trade_data['time'].append(order.time)
trade_data['side'].append(order.buyer)
price = order.end_price
returns.append(r)
prices.append(order.end_price)
if r > 1:
increases.append(r)
else:
decreases.append(r)
daily_decreases.append(np.mean(np.abs(np.log(decreases))))
daily_increases.append(np.mean(np.abs(np.log(increases))))
daily_price.append(order.end_price)
trade_data = pd.DataFrame(trade_data)
trade_data['price_change'] = np.log(
np.concatenate(([1], trade_data['price'].values[1:] /
trade_data['price'].values[:-1])))
movement = np.zeros(trade_data.shape[0])
movement[trade_data['price_change'] > 0] = 1
movement[trade_data['price_change'] < 0] = -1
chain = movement[movement != 0]
P, states = transition_probabilities(chain)
try:
p_00.append(P[states[1]][states[1]])
p_11.append(P[states[-1]][states[-1]])
except:
continue
daily_returns.append(np.mean(np.abs(np.log(returns))))
rates.append(24 * 60 * 60 * 1000 /
len(returns)) #average length of interarrival time
n_days = len(rates)
test_start = 250
test_len = 49
series = np.zeros((n_days, 5))
series[:, 0] = inv_sigmoid(np.array(p_00))
series[:, 1] = inv_sigmoid(np.array(p_11))
series[:, 2] = np.log(daily_increases)
series[:, 3] = np.log(daily_decreases)
series[:, 4] = np.log(rates)
k = 1
x, y = sort_data(series[:test_start], k)
reg = LinearRegression().fit(x, y)
initial = x[-k:]
prediction = np.array(predict(initial, reg, 49))
x = np.linspace(np.log(0.5), np.log(1.5), 1000)
means = []
variances = []
for i in range(prediction.shape[0]):
print('calculating day', i)
mu, var = calculate_normal_params(prediction[i])
means.append(mu)
variances.append(var)
means = np.cumsum(means)
vars = np.cumsum(variances)
start_price = daily_price[test_start - 1]
prices = daily_price[test_start:test_start + test_len]
plt.plot(prices)
plt.plot(np.exp(means) * start_price)
plt.plot(np.exp(means + 3 * vars) * start_price)
plt.plot(np.exp(means - 3 * vars) * start_price)
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
start = datetime.datetime(2018, 4, 1)
days = [start + datetime.timedelta(days = i) for i in range(460)]
daily_returns = []
daily_prices = []
rates = []
p_00 = []
p_11 = []
EMA = []
alpha = 2 / (50 + 1)
price = None
for start, end in zip(days[:-1], days[1:]):
print(start)
it = e.get_orders('BTCUSDT', start.timestamp() * 1000, end.timestamp() * 1000)
trade_data = {'price': [], 'time': [], 'side': []}
returns = []
prices = []
for order in it:
if price is None:
r = 1
price = order.end_price
continue
elif price != order.end_price:
r = order.end_price / price
else:
continue
trade_data['price'].append(order.end_price)
trade_data['time'].append(order.time)
trade_data['side'].append(order.buyer)
price = order.end_price
returns.append(r)
prices.append(order.end_price)
trade_data = pd.DataFrame(trade_data)
trade_data['price_change'] = np.log(np.concatenate(([1], trade_data['price'].values[1:] / trade_data['price'].values[:-1])))
movement = np.zeros(trade_data.shape[0])
movement[trade_data['price_change'] > 0] = 1
movement[trade_data['price_change'] < 0] = -1
chain = movement[movement != 0]
P, states = transition_probabilities(chain)
try:
p_11.append(P[states[1]][states[1]])
p_00.append(P[states[-1]][states[-1]])
except:
continue
daily_returns.append(np.log(np.mean(np.abs(np.log(returns)))))
rates.append(24 * 60 * 60 * 1000 / len(returns)) #average length of interarrival time
n_days = len(rates)
test_start = 400
test_len = 50
series = np.zeros((n_days, 4))
series[:, 0] = inv_sigmoid(np.array(p_00))
series[:, 1] = inv_sigmoid(np.array(p_11))
series[:, 2] = np.array(daily_returns)
series[:, 3] = np.log(np.array(rates))
k = 14
x, y = sort_data(series[:test_start], k)
reg = LinearRegression().fit(x, y)
x, y = sort_data(series[test_start - k : test_start + test_len], k)
prediction = reg.predict(x)
fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(2, 2)
errors = y - prediction
print(np.mean(errors, axis=0), np.cov(errors, rowvar=0))
plt.show()
def main():
e = exchange.Exchange('../lib/binance.db')
start = datetime.datetime(2018, 5, 1)
days = [start + datetime.timedelta(days = i) for i in range(10)]
daily_returns = []
daily_prices = []
rates = []
p_00 = []
p_11 = []
EMA = []
alpha = 2 / (50 + 1)
price = None
for start, end in zip(days[:-1], days[1:]):
print(start)
it = e.get_orders('BTCUSDT', start.timestamp() * 1000, end.timestamp() * 1000)
trade_data = {'price': [], 'time': [], 'side': []}
returns = []
prices = []
increases = []
decreases = []
for order in it:
if price is None:
r = 1
price = order.end_price
continue
elif price != order.end_price:
r = order.end_price / price
else:
continue
trade_data['price'].append(order.end_price)
trade_data['time'].append(order.time)
trade_data['side'].append(order.buyer)
price = order.end_price
returns.append(r)
prices.append(order.end_price)
if r > 1:
increases.append(r)
else:
decreases.append(r)
print(np.mean(np.log(increases)), np.mean(np.log(decreases)), np.mean(np.abs(np.log(returns))))
trade_data = pd.DataFrame(trade_data)
trade_data['price_change'] = np.log(np.concatenate(([1], trade_data['price'].values[1:] / trade_data['price'].values[:-1])))
movement = np.zeros(trade_data.shape[0])
movement[trade_data['price_change'] > 0] = 1
movement[trade_data['price_change'] < 0] = -1
print(np.sum(movement[movement == 1]) / movement.shape[0])
chain = movement[movement != 0]
P, states = transition_probabilities(chain)
try:
p_00.append(P[states[1]][states[1]])
p_11.append(P[states[-1]][states[-1]])
except:
continue
daily_returns.append(np.mean(np.abs(np.log(returns))))
rates.append(24 * 60 * 60 * 1000 / len(returns)) #average length of interarrival time
n_days = len(rates)
test_start = 2
test_len = 8
series = np.zeros((n_days, 4))
series[:, 0] = inv_sigmoid(np.array(p_00))
series[:, 1] = inv_sigmoid(np.array(p_11))
series[:, 2] = np.log(daily_returns)
series[:, 3] = np.log(rates)
k = 1
x, y = sort_data(series[:test_start], k)
reg = LinearRegression().fit(x, y)
x, y = sort_data(series[test_start - k : test_start + test_len], k)
x = np.linspace(-2,2, 100)
mean = 0
variance = 0
for i in range(7):
mu, var = calculate_normal_params(y[i])
mean += mu
variance += var
print(mu, variance)
plt.plot(np.exp(x), norm.pdf(x, loc = mean, scale = np.sqrt(variance)))
plt.show()
def annealingoptimize1(self,
arg_timetable,
arg_teacher,
temp=10000,
cool=0.99):
# 初期化
cnt = 0
penal = 1000000
# 解の記録
penalty_history = []
# オブジェクト生成
obj1 = exchange.Exchange()
obj2 = penalty.Penalty()
obj3 = arrangement.Arrangement()
# 探索
while penal > MIN_PENALTY or cnt < MAX_CNT:
# 交換
old_timetable = copy.deepcopy(arg_timetable)
if (penal >= 1000000):
obj1.exchange1(arg_timetable)
elif (penal >= 10000):
obj1.exchange2(arg_timetable)
else:
obj1.exchange3(arg_timetable)
# 先生配置
old_teacher = copy.deepcopy(arg_teacher)
new_teacher = copy.deepcopy(arg_teacher)
obj3.arrange_teacher(old_timetable, old_teacher)
obj3.arrange_teacher(arg_timetable, new_teacher)
# ペナルティを計算
old_pena = obj2.calc_penalty_soft(old_timetable, old_teacher)
new_pena = obj2.calc_penalty_soft(arg_timetable, new_teacher)
# 温度から確立を定義
pro = pow(math.e, -abs(new_pena - old_pena) / temp)
# コストを比較し改善 or 確率
if (new_pena < old_pena or random.random() < pro):
penal = new_pena
teacher = copy.copy(new_teacher)
else:
arg_timetable = copy.deepcopy(old_timetable)
penal = old_pena
teacher = copy.copy(old_teacher)
# 温度を下げる
temp = temp * cool
# カウントインクリメント
cnt += 1
# 表示
if cnt % 100 == 0:
print('penalty:', penal)
print('count :', cnt)
print()
# 探索が停滞
if cnt > 300 and penal > 1000000:
break
# ペナルティ
penalty_history.append(penal)
# 表示
print('----------------------')
print('penalty: ', penal)
print('----------------------')
# 戻り値
return arg_timetable, teacher, penal, penalty_history
def main():
#load data
e = exchange.Exchange('../lib/binance.db')
start = int(datetime.datetime(2019, 6, 1).timestamp() * 1000)
end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000)
#end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000)
print('Loading order data...')
number_of_orders, prices = e.get_total_orders_ts('BTCUSDT', 60 * 1000, start, end) #hourly data
print('done')
buy_orders = np.array([b for s, b in number_of_orders])
sell_orders = np.array([s for s, b in number_of_orders])
t = [i for i, o in enumerate(buy_orders)]
eemd = EEMD()
emd = eemd.EMD
eIMFs_buys = eemd.eemd(buy_orders)
eIMFs_sells = eemd.eemd(sell_orders)
if eIMFs_buys.shape[0] != eIMFs_sells.shape[0]:
print('size mismatch')
n = min(eIMFs_buys.shape[0], eIMFs_sells.shape[0])
fig, axs = plt.subplots(n + 2, figsize=(12,9), sharex=True)
axs[0].plot(prices)
axs[0].set_ylabel('Price')
axs[1].plot(buy_orders, color='g')
axs[1].plot(sell_orders, color='r')
axs[1].set_ylabel('Orders')
for i in range(n):
axs[i + 2].plot(eIMFs_buys[i], color='g')
axs[i + 2].plot(eIMFs_sells[i], color='r')
axs[i + 2].set_ylabel('eIMF ' + str(i + 1))
plt.xlabel("Time /days")
plt.tight_layout()
plt.show()
def greatdelugels(self, arg_timetable, arg_teacher):
# 初期化 cnt_stag:停滞回数
cnt_stag = 0
penalty_history = []
# オブジェクト生成
obj1 = exchange.Exchange()
obj2 = penalty.Penalty()
obj3 = arrangement.Arrangement()
# 先生配置
teacher = copy.deepcopy(arg_teacher)
obj3.arrange_teacher(arg_timetable, teacher)
# ペナルティ計算
cost_current = obj2.calc_penalty_soft(arg_timetable, teacher)
# 最小ペナルティ
min_cost = cost_current
# 初期水位
water_level = cost_current
# ペナルティ記録
penalty_history.append(cost_current)
# ループ
while min_cost > 0 and cnt_stag < MAX_STAG2:
### LocalSearch ###
# リスト
penal = []
timetable = []
teacher = []
# 近傍探索
for x in range(5):
# コピー
timetable.append(copy.deepcopy(arg_timetable))
# 交換
obj1.exchange3(timetable[x])
# 先生配置
teacher.append(copy.deepcopy(arg_teacher))
obj3.arrange_teacher(timetable[x], teacher[x])
# 現在のペナルティ
penal.append(obj2.calc_penalty_soft(timetable[x], teacher[x]))
# 最小要素
min_element = penal.index(min(penal))
timetable = copy.deepcopy(timetable[min_element])
teacher = copy.deepcopy(teacher[min_element])
cost_neigh = min(penal)
# 改善 or 水位以下
if cost_current >= cost_neigh or water_level >= cost_neigh:
# 交換を許可
arg_timetable = copy.deepcopy(timetable)
cost_current = cost_neigh
# 改善
if cost_current < min_cost:
# ペナルティ
min_cost = cost_current
min_timetable = copy.deepcopy(arg_timetable)
cnt_stag = 0
# 水位以下
if cost_current < water_level:
# 水位を下げる
water_level -= DEC_WATER2
# 同じ
if cost_current == min_cost or cost_current == water_level:
cnt_stag += 1
else:
cnt_stag += 1
# ペナルティ
penalty_history.append(cost_current)
# 再上昇
if cnt_stag % FREQ_RERISE2 == 0:
water_level += RERISE2
# 表示
print('min_pena', min_cost)
print('cur_pena', cost_current)
print('water_level', water_level)
print('cnt_stag', cnt_stag)
print()
# ペナルティ記録
penalty_history.append(cost_current)
obj3.arrange_teacher(min_timetable, arg_teacher)
return min_timetable, arg_teacher, min_cost, penalty_history
import os, sys, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
import exchange as e
import consumer as c
import numpy as np
# Declare number of goods, consumers and elasticity of substitution (rho)
num_commods = 6
num_consumers = 4
rho = 1
supply = np.zeros(num_commods)
# Create consumers
consumers = []
for i in range(num_commods):
endowment = np.random.randint(4, size=num_commods)
valuation = np.random.randint(5, size=num_commods)
supply += endowment
consumers.append(c.Consumer(endowment, valuation, rho))
# Create economy
economy = e.Exchange(consumers, num_commods)
# print(f"The excess demand at low prices: {economy.get_excess()}")
economy.tatonnement(learning_rate = 0.1)
# print(f"The total supply of each commodity is {supply}")
def main():
e = exchange.Exchange('../lib/binance.db')
times = [
datetime.datetime(2018, 4, 1) + i * datetime.timedelta(hours=1)
for i in range(10000)
]
variances = []
prices = []
average_distances = []
order_average = 25
for start, end in zip(times[:-1], times[1:]):
print(start)
it = e.get_orders('BTCUSDT',
start.timestamp() * 1000,
end.timestamp() * 1000)
trades = {'price': [], 'time': []}
for order in it:
trades['time'].append(order.time)
trades['price'].append(order.average_price)
trades = pd.DataFrame(trades)
if trades['time'].values.shape[0] == 0:
continue
price_changes = np.diff(trades['price'])
average_distances.append(
np.mean(
np.abs(trades['price'][order_average - 1:] -
moving_average(trades['price'].values, order_average))))
variances.append(np.var(price_changes))
fig, (ax1, ax2) = plt.subplots(2)
fig.suptitle('Variance against distance to moving average analysis')
lad = np.log(average_distances)
lv = np.log(variances)
reg = LinearRegression().fit(lad.reshape(-1, 1), lv)
ax1.scatter(lad, lv, alpha=0.3)
ax1.set_ylabel('log variance')
ax1.set_xlabel('log distance to moving average')
x = np.linspace(np.min(lad), np.max(lad), 2)
ax1.plot(x, reg.predict(x.reshape(-1, 1)), color='orange')
resid = lv - reg.predict(lad.reshape(-1, 1))
x = np.linspace(1 / resid.shape[0], 1 - 1 / resid.shape[0],
resid.shape[0] - 1)
ax2.scatter(norm.ppf(x), np.sort(resid)[1:])
reg = LinearRegression().fit(
norm.ppf(x).reshape(-1, 1),
np.sort(resid)[1:])
ax2.plot(norm.ppf(x),
reg.predict(norm.ppf(x).reshape(-1, 1)),
color='orange')
ax2.set_ylabel('Order Statistic')
plt.tight_layout()
plt.show()
import discord
from discord.ext import commands
import dbl
import aiohttp
import asyncio
import logging
import json
import random
from config import Config as cfg
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from decimal import Decimal
import exchange as ex
ex = ex.Exchange(cfg)
description = '''Stone Tip-Bot'''
bot = commands.Bot(command_prefix='?', description=description)
global logger
class soakobj:
member = {}
address = ""
class DiscordBotsOrgAPI:
"""Handles interactions with the discordbots.org API"""
def __init__(self, bot):
self.bot = bot
