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