def run(debug): base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 2 #60*24*30*4 interval = 60 #dtend = datetime.datetime.strptime('2018-05-02 15:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-05-24 17:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) #inp = json.load(open('misc/json_BTCUSDT_60min.json')) uncertainty_margin = 0.001 def sig(prev_len, prevPrice, price): multiplier = (2 / float(1 + prev_len)) v = price * multiplier + prevPrice * (1 - multiplier) return v def normalize(arr): a = arr[:] mi = min(a) ma = max(a) if (ma - mi) == 0: return [0.0] for i, v in enumerate(a): a[i] = (a[i] - mi) / (ma - mi) return a def work(_1, _2, _3, _4, _5, _6): portfolio = {} dtit = dtstart traceA = core.createNewScatterTrace("traceA", "y") traceA['prev_len'] = _1 traceB = core.createNewScatterTrace("traceB", "y") traceB['prev_len'] = _2 traceC = core.createNewScatterTrace("W&L", "y2") usage = { 'canBuy': True, 'canSell': False, 'buyPrice': None, 'sellPrice': None, 'prevPrice': None, 'win': 0, 'loss': 0, } bucket = [] while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] price = (o + c + l + h) / 4 # ok #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) #price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) pA = sig( traceA['prev_len'], np.average(traceA['y'][-_3:]) if len(traceA['y']) > 0 else (o + c) / 2, (o + c) / 2) pB = sig( traceB['prev_len'], np.average(traceB['y'][-_3:]) if len(traceB['y']) > 0 else (o + c) / 2, (o + c) / 2) core.addToScatterTrace(traceA, dtit, pA) core.addToScatterTrace(traceB, dtit, pB) bucket.append(pA) # dummy def buyF(): if np.average(traceB['y'][-_4:]) > traceB['y'][-1]: return False if traceB['y'][-2] > traceA['y'][-2] and traceB['y'][ -1] < traceA['y'][-1]: return True if traceB['y'][-1] > traceB['y'][-2]: return True def sellF(): if price > usage['buyPrice'] * _5 and not buyF(): usage['win'] += 1 return True if price < usage['buyPrice'] * _6: usage['loss'] += 1 return True if len(bucket) > 2: if usage['canBuy'] and buyF(): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = True usage['canBuy'] = False usage['buyPrice'] = price elif usage['canSell'] and sellF(): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = False usage['canBuy'] = True usage['sellPrice'] = price core.addToScatterTrace(traceC, dtit, (1 + usage['win']) / (1 + usage['loss'])) usage['prevPrice'] = price dtit += datetime.timedelta(minutes=interval) for i, v in enumerate( traceB['y']): # beautify (replacing 0's by None ) if v == 0: traceB['y'][i] = None proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [ traceA, traceB, traceC, ]) if debug == 0: # computing ROI A = 2 B = 15 C = 5 D = 10 E = 1.02 F = 0.97 avgs = [] for x in range(100): (proc, portfolio, traces) = work(A, B, C, D, E, F) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in range(1, 30): for B in range(2, 30): for C in range(1, 10): for D in range(5, 15): for E in [1 + x / 100 for x in range(0, 10)]: for F in [0.90 + x / 100 for x in range(0, 10)]: if (B <= A): continue avgs = [] for x in range(20): (proc, portfolio, traces) = work(A, B, C, D, E, F) #print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("%f %f %f %f %f %f" % (A, B, C, D, E, F)) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs) / len(avgs)) in dct: dct[str( sum(avgs) / len(avgs) )] = str(A) + "_" + str(B) + "_" + str( C) + "_" + str(D) + "_" + str( E) + "_" + str(F) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: # computing and plotting out A = 2 B = 15 C = 5 D = 10 E = 1.02 F = 0.97 (proc, portfolio, traces) = work(A, B, C, D, E, F) print("ROI: (%i, %i) %f" % (A, B, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): # this strategy works best at 1hr intervals # 1. the idea is based on calculating the slope of the current price (which is a random price at interval 't') against the previous close price. # 2. it also makes sure a buy occurs when the current price is higher than the previous one # 3. base = "BTC" #base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 4 #60*24*30*4 interval = 120 dtend = datetime.datetime.strptime('2018-04-15 00:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) uncertainty_margin = 0.001 def EMA(_arr, size, iterations=2): # simplified version multiplier = (2 / float(1 + size)) arr = _arr[:] # slice/copy it for j in range(iterations): ema = [arr[0]] for i in range(1, len(arr)): v = (arr[i] * multiplier) + (ema[i - 1] * (1 - multiplier)) ema.append(v) arr = ema[:] return arr def sig(prev_len, prevs, price, num): x = price - np.average(prevs[-prev_len:]) u = EMA(prevs[-prev_len:], prev_len, 1) z = np.average(u) x = (-1 if x < 0 else 1) * math.log(abs(z / prev_len)) x = (-num if x < 0 else num) return x def sig2(prev_len, prevs, price): u = EMA(prevs, prev_len, 1) z = u[-1] return z def isDownTrend(arr): if len(arr) < 10: return True arr = arr[:] j = int(len(arr) / 3) first = np.average(arr[:j]) mid = np.average(arr[j:j * 2]) last = np.average(arr[-j:]) if first > mid or mid > last: return True return False def work(): portfolio = {} dtit = dtstart prevs = [] canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y2") traceA['prev_len'] = 10 traceB = core.createNewScatterTrace("traceB", "y") traceB[ 'prev_len'] = 12 # make sure it's large enough ( >= 12) for isDownTrend formula upduration_A = 0 downduration_A = 0 prevBuyPrice = 0 while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] price = (o + c) / 2 # ok # price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok # price = random.uniform(o, c) if c > o else random.uniform(c, o) # price = random.uniform(l, h) # much worse than [open, close] buyprice = price sellprice = price core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) if len(prevs) > 0: core.addToScatterTrace( traceA, dtit, sig(traceA['prev_len'], prevs, price, 1)) core.addToScatterTrace( traceB, dtit, sig2(traceB['prev_len'], prevs, price)) if len(traceA['y']) > 1: if traceA['y'][-1] > 0 and traceA['y'][ -2] > 0: # A up -> up upduration_A += 1 if traceA['y'][-1] < 0 and traceA['y'][ -2] > 0: # A up -> down upduration_A = 0 if traceA['y'][-1] < 0 and traceA['y'][ -2] < 0: # A down -> down downduration_A += 1 if traceA['y'][-1] > 0 and traceA['y'][ -2] < 0: # A down -> up downduration_A = 0 if canBuy and isDownTrend( traceB['y'][-traceB['prev_len']:]) == False: if traceA['y'][-1] > 0 and traceA['y'][ -2] < 0: # B down -> up core.portfolioBuy(portfolio, dtit, buyprice, uncertainty_margin) prevBuyPrice = buyprice canSell = True canBuy = False elif canSell: if traceA['y'][-1] < 0 and traceA['y'][ -2] > 0: # B up -> down core.portfolioSell(portfolio, dtit, sellprice, uncertainty_margin) canSell = False canBuy = True else: core.addToScatterTrace(traceA, dtit, 0) # use 0 instead of None core.addToScatterTrace(traceB, dtit, 0) # use 0 instead of None prevs.append(price) # else: # print("missing: " + str(idx)) dtit += datetime.timedelta(minutes=interval) # beautify (replacing 0's by None ) for i, v in enumerate(traceB['y']): if v == 0: traceB['y'][i] = None proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceA, traceB]) if debug == 0: avgs = [] for x in range(100): (proc, portfolio, traces) = work() print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) else: (proc, portfolio, traces) = work() print("ROI: %f" % proc['_']['ROI%']) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60*24*30*2 #60*24*30*4 interval = 60 dtend = datetime.datetime.strptime('2018-05-02 15:00', '%Y-%m-%d %H:%M') #dtend = datetime.datetime.strptime('2018-05-17 12:00', '%Y-%m-%d %H:%M') #dtend = datetime.datetime.strptime('2018-06-02 12:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-07-26 10:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) preds = core.getPredictions_v1('binance', interval, base, quote, historymins, dtend) #preds = json.load(open('misc/preds1.json')) uncertainty_margin = 0.001 def work(_1, _2, _3, _4): portfolio = {} dtit = dtstart canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y") traceB = core.createNewScatterTrace("traceB", "y") buyPrice = None prevC = None prevCavg = None bucket=[] while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] #price = (o+c+l+h)/4 # ok #price = (o+c)/2 # ok #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) shouldBuy=False if idx in preds: x1,y1=list(preds[idx].items())[0] x2,y2=list(preds[idx].items())[1] _2 = 1.002 if ((y2['open']+y2['high']+y2['low']+y2['close'])/4) > ((y1['open']+y1['high']+y1['low']+y1['close'])/4)*_2: shouldBuy=True #if canBuy and (prevCavg < 0 and pCavg > 0) and pE > 0: if canBuy and shouldBuy : core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) canSell = True canBuy = False buyPrice = price elif canSell and (price > buyPrice*_3 or price < buyPrice*_4): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) canSell = False canBuy = True dtit += datetime.timedelta(minutes=interval) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [ traceA, traceB ]) if debug == 0: # computing ROI A = 2 B = 15 C = 1.03 D = 0.95 avgs = [] for x in range(100): (proc, portfolio, traces) = work(A, B, C, D) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs)/len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in range(1, 30): for B in range(2, 30): if (B <= A): continue for C in [1+x/100 for x in range(0, 10)]: for D in [0.90+x/100 for x in range(0, 10)]: avgs = [] for x in range(20): (proc, portfolio, traces) = work(A,B,C,D) #print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("%f %f %f %f" % (A,B,C,D)) print("avg ROI%: " + str(sum(avgs)/len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs)/len(avgs)) in dct: dct [ str(sum(avgs)/len(avgs)) ] = str(A)+"_"+str(B)+"_"+str(C)+"_"+str(D) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: # computing and plotting out A = 2 B = 15 C = 1.03 D = 0.95 (proc, portfolio, traces) = work(A, B, C, D) print("ROI: (%i, %i %f %f) %f" % (A,B,C,D, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 1 #60*24*30*4 interval = 60 dtend = datetime.datetime.strptime('2018-04-26 15:00', '%Y-%m-%d %H:%M') # dtend = datetime.datetime.strptime('2018-05-17 12:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) #inp = json.load(open('misc/json_BTCUSDT_60min.json')) uncertainty_margin = 0.001 def sig(prev_len, prevPrice, price): multiplier = (2 / float(1 + prev_len)) v = price * multiplier + prevPrice * (1 - multiplier) return v def normalize(arr): a = arr[:] mi = min(a) ma = max(a) if (ma - mi) == 0: return [0.0] for i, v in enumerate(a): a[i] = (a[i] - mi) / (ma - mi) return a def work(_1, _2, _3): portfolio = {} dtit = dtstart traceD = core.createNewScatterTrace("traceD", "y2") usage = { 'canBuy': True, 'canSell': False, 'buyPrice': None, 'sellPrice': None, 'prevPrice': None, } bucket = [] bucketstd = [] while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] price = (o + c + l + h) / 4 # ok #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) def buyF(): if len(traceD['y']) < 2: return False if traceD['y'][-2] == 1 and traceD['y'][-1] == -1: return True #if traceD['y'][-1] == 1 and traceD['y'][-2] == -1: # return True def sellF(): if price > usage['buyPrice'] * _1: return True if price < usage['buyPrice'] * _2: return True if len(bucket) > 2: pD = np.average(bucket[-_3:]) pD = 1 if pD > 1 else -1 core.addToScatterTrace(traceD, dtit, pD) if usage['canBuy'] and buyF(): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = True usage['canBuy'] = False usage['buyPrice'] = price elif usage['canSell'] and sellF(): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = False usage['canBuy'] = True usage['sellPrice'] = price usage['countSinceSell'] = 0 if usage['prevPrice'] != None: bucket.append(price / usage['prevPrice']) usage['prevPrice'] = price dtit += datetime.timedelta(minutes=interval) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceD]) if debug == 0: # computing ROI A = 1.03 B = 0.96 C = 16 avgs = [] for x in range(100): (proc, portfolio, traces) = work(A, B, C) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in [1 + x / 100 for x in range(1, 6)]: for B in [0.95 + x / 100 for x in range(0, 5)]: for C in range(1, 20): avgs = [] for x in range(20): (proc, portfolio, traces) = work(A, B, C) #print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("%f %f %f" % (A, B, C)) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs) / len(avgs)) in dct: dct[str( sum(avgs) / len(avgs))] = str(A) + "_" + str(B) + "_" + str(C) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: # computing and plotting out # A = 1.02 # B = 0.98 # C = 9 A = 1.03 B = 0.97 C = 16 (proc, portfolio, traces) = work(A, B, C) print("ROI: (%f %f %i) %f" % (A, B, C, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): base = "BTC" #base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 1 #60*24*30*4 interval = 60 dtend = datetime.datetime.strptime('2018-04-15 00:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) uncertainty_margin = 0.001 def sig(prev_len, prevY, prevs, price): if len(prevY) == 0: return price multiplier = (2 / float(1 + prev_len)) v = price * multiplier + prevY[-1] * (1 - multiplier) return v def work(_1, _2): portfolio = {} dtit = dtstart prevs = [] canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y") traceA['prev_len'] = _1 traceB = core.createNewScatterTrace("traceB", "y") traceB['prev_len'] = _2 while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] #price = (o+c)/2 # ok # price = c # ok price = o + (c - o) * random.randint(0, 10) / 10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) # price = random.uniform(l, h) # much worse than [open, close] buyprice = price sellprice = price core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) core.addToScatterTrace( traceA, dtit, sig(traceA['prev_len'], traceA['y'], prevs, price)) core.addToScatterTrace( traceB, dtit, sig(traceB['prev_len'], traceB['y'], prevs, price)) if len(traceA['y']) > 1: if canBuy and (traceA['y'][-2] < traceB['y'][-2] and traceA['y'][-1] > traceB['y'][-1]): core.portfolioBuy(portfolio, dtit, buyprice, uncertainty_margin) canSell = True canBuy = False elif canSell and (traceA['y'][-2] > traceB['y'][-2] and traceA['y'][-1] < traceB['y'][-1]): core.portfolioSell(portfolio, dtit, sellprice, uncertainty_margin) canSell = False canBuy = True prevs.append(price) dtit += datetime.timedelta(minutes=interval) # beautify (replacing 0's by None ) for i, v in enumerate(traceB['y']): if v == 0: traceB['y'][i] = None proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceA, traceB]) if debug == 0: # computing ROI A = 1 B = 2 avgs = [] for x in range(100): (proc, portfolio, traces) = work(A, B) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A & B) arr = [] for A in range(1, 30): for B in range(2, 30): if (B <= A): continue rois = [] for x in range(5): (proc, portfolio, traces) = work(A, B) rois.append(proc['_']['ROI%']) arr.append({"ROI": np.average(rois), "A": A, "B": B}) print("ROI: %i %i %f" % (A, B, np.average(rois))) print(sorted(arr, key=lambda x: x['ROI'])) else: # computing and plotting out A = 8 B = 23 (proc, portfolio, traces) = work(A, B) print("ROI: (%i, %i) %f" % (A, B, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): # this strategy works best at 1hr intervals # 1. the idea is based on calculating the slope of the current price (which is a random price at interval 't') against the previous close price. # 2. it also makes sure a buy occurs when the current price is higher than the previous one # 3. base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60*24*30*3 #60*24*30*4 dtend = datetime.datetime.strptime('2018-04-18 00:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) interval = 60 inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) uncertainty_margin = 0.001 slope_pct_threshold = 0.3 def work(dtstart, dtend): portfolio = {} prevPrice = None slopes = [] dtit = dtstart while dtit < dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] # let price be any random value in range [open, close] # price = random.uniform(o, c) if c > o else random.uniform(c, o) # price = random.uniform(l, h) # much worse than [open, close] # let the price be any random value in range [open ; (close-open)*x ] where x is in range [0.0 ; 1.0] price = o + (c-o)*random.randint(0,10)/10 # this strategy seems to stop working when we use range [low, high] # however in reality there is a chance the system takes near-low/high values, as a result the ROI will be low or even negative. buyprice = price sellprice = price core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) if prevPrice != None: slope_pct = round((price-prevPrice)/prevPrice*100,2) slopes.append(slope_pct) if price > prevPrice: slopes.append( slope_pct ) avgS = sum(slopes)/len(slopes) if avgS > slope_pct_threshold : # len(slopes) > 1 and # buy core.portfolioBuy(portfolio, dtit, buyprice, uncertainty_margin) else: if len(slopes) > 0: # sell core.portfolioSell(portfolio, dtit, sellprice, uncertainty_margin) slopes = [] prevPrice = c dtit += datetime.timedelta(minutes=interval) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio) if debug == 0: avgs = [] for x in range(100): (proc, portfolio) = work(dtstart, dtend) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs)/len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) else: (proc, portfolio) = work(dtstart, dtend) print("ROI: %f" % proc['_']['ROI%']) core.portfolioToChart_OHLC(portfolio)
def run(debug): base = "BTC" base = "ETH" base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 3 #60*24*30*4 interval = 60 dtend = datetime.datetime.strptime('2018-05-02 15:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-05-17 12:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) uncertainty_margin = 0.001 def sig(prev_len, prevY, price): if len(prevY) == 0: return price multiplier = (2 / float(1 + prev_len)) v = price * multiplier + prevY[-1] * (1 - multiplier) return v def normalize(arr): a = arr[:] mi = min(a) ma = max(a) if (ma - mi) == 0: return [0.0] for i, v in enumerate(a): a[i] = (a[i] - mi) / (ma - mi) return a def work(_1, _2, _3, _4): portfolio = {} dtit = dtstart canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y") traceA['prev_len'] = _1 traceB = core.createNewScatterTrace("traceB", "y") traceB['prev_len'] = _2 traceC = core.createNewScatterTrace("traceC", "y2") traceD = core.createNewScatterTrace("traceD", "y2") buyPrice = None prevC = None prevCavg = None bucket = [] while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] #price = (o+c+l+h)/4 # ok #price = (o+c)/2 # ok #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) pA = sig(traceA['prev_len'], traceA['y'], o) pB = sig(traceB['prev_len'], traceB['y'], c) pC = pA - pB pC = sig(3, [prevC if prevC != None else pC], pC) bucket.append(pC) pCavg = np.average(bucket[-10:]) core.addToScatterTrace(traceA, dtit, pA) core.addToScatterTrace(traceB, dtit, pB) core.addToScatterTrace(traceC, dtit, pC) core.addToScatterTrace(traceD, dtit, pCavg) if len(bucket) > 2: if canBuy and (prevCavg < 0 and pCavg > 0): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) canSell = True canBuy = False buyPrice = price elif canSell and (price > buyPrice * _3 or price < buyPrice * _4): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) canSell = False canBuy = True prevC = pC prevCavg = pCavg dtit += datetime.timedelta(minutes=interval) for i, v in enumerate( traceB['y']): # beautify (replacing 0's by None ) if v == 0: traceB['y'][i] = None proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceA, traceB, traceC, traceD]) if debug == 0: # computing ROI A = 2 B = 15 C = 1.03 D = 0.97 avgs = [] for x in range(100): (proc, portfolio, traces) = work(A, B, C, D) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in range(1, 30): for B in range(2, 30): if (B <= A): continue for C in [1 + x / 100 for x in range(0, 10)]: for D in [0.90 + x / 100 for x in range(0, 10)]: avgs = [] for x in range(20): (proc, portfolio, traces) = work(A, B, C, D) #print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("%f %f %f %f" % (A, B, C, D)) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs) / len(avgs)) in dct: dct[str(sum(avgs) / len(avgs))] = str( A) + "_" + str(B) + "_" + str(C) + "_" + str(D) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: # computing and plotting out A = 2 B = 15 C = 1.03 D = 0.97 (proc, portfolio, traces) = work(A, B, C, D) print("ROI: (%i, %i %f %f) %f" % (A, B, C, D, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): base = "BTC" base = "ETH" base = "LTC" quote = "USDT" historymins = 60 * 6 #60*24*1 #60*24*30*1 #60*24*30*4 interval = 1 #60 #dtend = datetime.datetime.strptime('2018-05-02 15:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-05-24 12:30', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) #inp = json.load(open('misc/json_BTCUSDT_60min.json')) #uncertainty_margin = 0.001 uncertainty_margin = 0.0005 # slippage if debug == 0: # computing ROI A = 2 B = 1.007 C = 0.993 avgs = [] for x in range(100): (proc, portfolio, traces) = work(dtstart, dtend, inp, interval, uncertainty_margin, A, B, C) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in range(2, 10): for B in [1 + x / 1000 for x in range(3, 10)]: for C in [0.99 + x / 1000 for x in range(3, 10)]: #if (B <= A): continue avgs = [] for x in range(1): (proc, portfolio, traces) = work(dtstart, dtend, inp, interval, uncertainty_margin, A, B, C) #print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) if sum(avgs) / len(avgs) < 0: continue # skip negatives print("%f %f %f %f %f %f" % (A, B, C, D, E, F)) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) #print("std ROI%: " + str(std)) if not str(sum(avgs) / len(avgs)) in dct: dct[str( sum(avgs) / len(avgs))] = str(A) + "_" + str(B) + "_" + str(C) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: # computing and plotting out shapes = [ { 'type': 'line', 'xref': 'x', 'yref': 'y2', 'x0': datetime.datetime.strftime(dtstart, '%Y-%m-%dT%H:%M'), 'x1': datetime.datetime.strftime(dtend, '%Y-%m-%dT%H:%M'), 'y0': 50, 'y1': 50, 'line': { 'color': 'gray', 'width': 3, 'dash': 'dash' }, }, { 'type': 'line', 'xref': 'x', 'yref': 'y2', 'x0': datetime.datetime.strftime(dtstart, '%Y-%m-%dT%H:%M'), 'x1': datetime.datetime.strftime(dtend, '%Y-%m-%dT%H:%M'), 'y0': 70, 'y1': 70, 'line': { 'color': 'gray', 'width': 2, }, }, { 'type': 'line', 'xref': 'x', 'yref': 'y2', 'x0': datetime.datetime.strftime(dtstart, '%Y-%m-%dT%H:%M'), 'x1': datetime.datetime.strftime(dtend, '%Y-%m-%dT%H:%M'), 'y0': 30, 'y1': 30, 'line': { 'color': 'gray', 'width': 2, }, }, ] A = 7 B = 1.002 C = 0.991 (proc, portfolio, traces) = work(dtstart, dtend, inp, interval, uncertainty_margin, A, B, C) print("ROI: (%i, %i) %f" % (A, B, proc['_']['ROI%'])) core.portfolioToChart_OHLC(portfolio, traces, shapes=shapes)
def run(debug): base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 30 * 2 #60*24*30*4 interval = 30 dtend = datetime.datetime.strptime('2018-05-28 23:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) # inp = json.load(open("./LTC_60m.json")) uncertainty_margin = 0.001 def EMAsingle(size, prevY, price): if len(prevY) == 0: return price multiplier = (2 / float(1 + size)) v = price * multiplier + prevY[-1] * (1 - multiplier) return v def finalizeTrace(trace): # beautify (replacing 0's by None ) for i, v in enumerate(trace['y']): if v == 0: trace['y'][i] = None def sigA(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg + std out = EMAsingle(hp_arrEL, y, out) return out def sigC(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg - std out = EMAsingle(hp_arrEL, y, out) return out def work(): portfolio = {} dtit = dtstart canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y") traceC = core.createNewScatterTrace("traceC", "y") hp_arrL = 35 hp_arrEL = 4 while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: volume = inp[idx]['volume'] trades = inp[idx]['trades'] c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] price = random.randint( int(l), int(h)) if int(h) > int(l) else random.randint( int(h), int(l) ) # still "okay" but much worse than [open, close] core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) pA = sigA(traceA['y'], traceA['z'], price, hp_arrL, hp_arrEL) pC = sigC(traceC['y'], traceA['z'], price, hp_arrL, hp_arrEL) core.addToScatterTrace(traceA, dtit, pA) core.addToScatterTrace(traceC, dtit, pC) #if canBuy and (pC >= o and pC <= c): if canBuy and (pC >= l and pC <= h): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) canSell = True canBuy = False #elif canSell and (pA >= c and pA <= o): elif canSell and (pA >= l and pA <= h): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) canSell = False canBuy = True dtit += datetime.timedelta(minutes=interval) finalizeTrace(traceA) finalizeTrace(traceC) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceA, traceC]) if debug == 0: avgs = [] for x in range(100): (proc, portfolio, traces) = work() print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) else: (proc, portfolio, traces) = work() print("ROI: %f" % proc['_']['ROI%']) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): base = "BTC" base = "ETH" #base = "LTC" quote = "USDT" historymins = 60 * 24 * 2 #60*24*30*4 interval = 1 dtend = datetime.datetime.strptime('2018-05-01 12:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-05-30 12:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) # inp = json.load(open("./LTC_60m.json")) uncertainty_margin = 0.001 def EMAsingle(size, prevY, price): if len(prevY) == 0: return price multiplier = (2 / float(1 + size)) v = price * multiplier + prevY[-1] * (1 - multiplier) return v def sigA(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg + std out = EMAsingle(hp_arrEL, y, out) return out def sigC(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg - std out = EMAsingle(hp_arrEL, y, out) return out def work(_1, _2): portfolio = {} dtit = dtstart canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA", "y") traceC = core.createNewScatterTrace("traceC", "y3") traceD = core.createNewScatterTrace("traceD", "y3") traceE = core.createNewScatterTrace("traceE", "y3") traceF = core.createNewScatterTrace("traceF", "y3") hp_arrL = 35 hp_arrEL = 4 usage = { 'canBuy': True, 'canSell': False, 'buyPrice': None, 'prevPrice': None } while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: volume = inp[idx]['volume'] trades = inp[idx]['trades'] c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] price = (o + c + l + h) / 4 # ok #price = (o+c)/2 #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) #price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) core.addToScatterTrace(traceC, dtit, (c - o)) core.addToScatterTrace( traceD, dtit, np.std(traceC['y'][-16:]) * 2 + np.average([abs(x) for x in traceC['y'][-16:]])) def buyF(): if len(traceD['y']) < 2: return False if traceC['y'][-2] < traceD['y'][-2] and traceC['y'][ -1] > traceD['y'][-1]: return True def sellF(): if price > usage['buyPrice'] * _1: #and not buyF(): return True if price < usage['buyPrice'] * _2: return True if usage['canBuy'] and buyF(): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = True usage['canBuy'] = False usage['buyPrice'] = price elif usage['canSell'] and sellF(): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = False usage['canBuy'] = True usage['sellPrice'] = price usage['prevPrice'] = price dtit += datetime.timedelta(minutes=interval) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [ traceA, traceC, traceD, traceE, traceF, ]) if debug == 0: avgs = [] for x in range(100): (proc, portfolio, traces) = work(1.03, 0.96) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in [1 + x / 100 for x in range(1, 10)]: for B in [0.90 + x / 100 for x in range(1, 10)]: avgs = [] #for x in range(100): for x in range(1): (proc, portfolio, traces) = work(A, B) avgs.append(proc['_']['ROI%']) print("%f %f" % (A, B)) print("avg ROI%: " + str(sum(avgs) / len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs) / len(avgs)) in dct: dct[str(sum(avgs) / len(avgs))] = str(A) + "_" + str(B) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: (proc, portfolio, traces) = work(1.02, 0.98) print("ROI: %f" % proc['_']['ROI%']) core.portfolioToChart_OHLC(portfolio, traces)
def run(debug): # this strategy works best at 1hr intervals # 1. the idea is based on calculating the slope of the current price (which is a random price at interval 't') against the previous close price. # 2. it also makes sure a buy occurs when the current price is higher than the previous one # 3. base = "BTC" #base = "ETH" #base = "LTC" quote = "USDT" historymins = 60*24*30*2 #60*24*30*4 interval = 30 dtend = datetime.datetime.strptime('2018-05-01 12:00', '%Y-%m-%d %H:%M') dtend = datetime.datetime.strptime('2018-05-26 12:00', '%Y-%m-%d %H:%M') dtstart = dtend - datetime.timedelta(minutes=historymins) inp = core.getPriceExchange_v1('binance', interval, base, quote, historymins, dtend) # inp = json.load(open("./LTC_60m.json")) uncertainty_margin = 0.001 def EMAsingle(size, prevY, price): if len(prevY) == 0: return price multiplier = (2 / float(1 + size)) v = price*multiplier + prevY[-1]*(1-multiplier) return v def sigA(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg + std out = EMAsingle(hp_arrEL, y, out) return out def sigC(y, z, price, hp_arrL, hp_arrEL): z.append(price) L = hp_arrL avg = np.average(z[-L:]) std = np.std(z[-L:]) * 2 out = avg - std out = EMAsingle(hp_arrEL, y, out) return out def work(_1, _2): portfolio = {} dtit = dtstart canBuy = True canSell = False traceA = core.createNewScatterTrace("traceA" ,"y") traceC = core.createNewScatterTrace("traceC" ,"y2", 'markers') traceD = core.createNewScatterTrace("traceD" ,"y2", 'markers') traceE = core.createNewScatterTrace("traceE" ,"y3") hp_arrL = 35 hp_arrEL = 4 usage = { 'canBuy': True, 'canSell': False, 'buyPrice': None, 'timeHeld': 0, } while dtit <= dtend: idx = datetime.datetime.strftime(dtit, '%Y-%m-%dT%H:%M') if idx in inp: volume = inp[idx]['volume'] trades = inp[idx]['trades'] c = inp[idx]['close'] o = inp[idx]['open'] l = inp[idx]['low'] h = inp[idx]['high'] #price = (o+c+l+h)/4 # ok price = (o+c)/2 #price = c # ok #price = o + (c-o)*random.randint(0,10)/10 # ok #price = random.uniform(o, c) if c > o else random.uniform(c, o) #price = random.uniform(l, h) # reality core.portfolioPriceEntry(portfolio, dtit, price, o, c, l, h) core.addToScatterTrace(traceA, dtit, (o+h+l+c)/4) pC = 1-1/(1+(price/np.average(traceA['y'][-24:]))) core.addToScatterTrace(traceC, dtit, pC) core.addToScatterTrace(traceD, dtit, np.average(traceC['y'][-24:])) if len(traceD['y']) > 8: pD = 1 if np.average(traceD['y'][-8:-4]) > np.average(traceD['y'][-4:-2]) and np.average(traceD['y'][-4:-2]) < np.average(traceD['y'][-2:]) else 0 #pD = 1 if traceD['y'][-1] > traceD['y'][-3] and traceD['y'][-2] < traceD['y'][-3] and traceD['y'][-2] < traceD['y'][-1] else 0 core.addToScatterTrace(traceE, dtit, pD ) def buyF(): if len(traceE['y']) < 2: return False if traceE['y'][-2] == 0 and traceE['y'][-1]==1: return True def sellF(): if traceD['y'][-1] < .5 and usage['timeHeld'] > 5: return True if price > usage['buyPrice']*_1: #and not buyF(): return True if price < usage['buyPrice']*_2: return True if usage['canBuy'] and buyF(): core.portfolioBuy(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = True usage['canBuy'] = False usage['timeHeld'] = 0 usage['buyPrice'] = price elif usage['canSell'] and sellF(): core.portfolioSell(portfolio, dtit, price, uncertainty_margin) usage['canSell'] = False usage['canBuy'] = True usage['timeHeld'] = 0 usage['sellPrice'] = price usage['timeHeld']+=1 dtit += datetime.timedelta(minutes=interval) proc = core.processPortfolio(portfolio, 1) return (proc, portfolio, [traceA, traceC, traceD, traceE, ]) if debug == 0: avgs = [] for x in range(100): (proc, portfolio, traces) = work(1.03, 0.96) print("%s ROI \t %f" % (str(x), proc['_']['ROI%'])) avgs.append(proc['_']['ROI%']) print("avg ROI%: " + str(sum(avgs)/len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) elif debug == 1: # brute-force searching for optimal parameters (A,B,C,D) dct = {} for A in [1+x/100 for x in range(1, 10)]: for B in [0.90+x/100 for x in range(1, 10)]: avgs = [] for x in range(20): (proc, portfolio, traces) = work(A,B) avgs.append(proc['_']['ROI%']) print("%f %f" % (A,B)) print("avg ROI%: " + str(sum(avgs)/len(avgs))) std = np.std(avgs) print("std ROI%: " + str(std)) if not str(sum(avgs)/len(avgs)) in dct: dct [ str(sum(avgs)/len(avgs)) ] = str(A)+"_"+str(B) print("--------") print(base) print("--------") print(json.dumps(dct)) print("--------") print(base) else: shapes = [ { 'type': 'line', 'xref': 'x', 'yref': 'y2', 'x0': datetime.datetime.strftime(dtstart, '%Y-%m-%dT%H:%M'), 'x1': datetime.datetime.strftime(dtend, '%Y-%m-%dT%H:%M'), 'y0': .50, 'y1': .50, 'line': { 'color': 'gray', 'width': 3, 'dash': 'dash' }, }, ] (proc, portfolio, traces) = work(1.02, 0.97) print("ROI: %f" % proc['_']['ROI%']) core.portfolioToChart_OHLC(portfolio, traces, shapes=shapes)