我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用scipy.stats.rankdata()。
def test_rank_methods_frame(self): tm.skip_if_no_package('scipy', '0.13', 'scipy.stats.rankdata') import scipy from scipy.stats import rankdata xs = np.random.randint(0, 21, (100, 26)) xs = (xs - 10.0) / 10.0 cols = [chr(ord('z') - i) for i in range(xs.shape[1])] for vals in [xs, xs + 1e6, xs * 1e-6]: df = DataFrame(vals, columns=cols) for ax in [0, 1]: for m in ['average', 'min', 'max', 'first', 'dense']: result = df.rank(axis=ax, method=m) sprank = np.apply_along_axis( rankdata, ax, vals, m if m != 'first' else 'ordinal') sprank = sprank.astype(np.float64) expected = DataFrame(sprank, columns=cols) if LooseVersion(scipy.__version__) >= '0.17.0': expected = expected.astype('float64') tm.assert_frame_equal(result, expected)
def score_candidates(reactants, candidate_list, xs): pred = model.predict(xs, batch_size = 20)[0] rank = ss.rankdata(pred) fname = raw_input('Enter file name to save to: ') + '.dat' with open(os.path.join(FROOT, fname), 'w') as fid: fid.write('FOR REACTANTS {}\n'.format(Chem.MolToSmiles(reactants))) fid.write('Candidate product\tCandidate edit\tProbability\tRank\n') for (c, candidate) in enumerate(candidate_list): candidate_smile = candidate[0] candidate_edit = candidate[1] fid.write('{}\t{}\t{}\t{}\n'.format( candidate_smile, candidate_edit, pred[c], 1 + len(pred) - rank[c] )) print('Wrote to file {}'.format(os.path.join(FROOT, fname)))
def precision_n(test_scores, num_true, n): """ Precision at n measure is the number of instances where the any crowd's answer occur within ranker's firs n choices For more details take a look at: http://www.aclweb.org/anthology/D13-1030 The first num_true_antec[i] dev_scores are predicted scores for true antecedents of the i-th sentence w/ PA :param test_scores: \in [batch_size, num of candidates], for every sent w\ PA predicted scores for its candidates :param num_true_antec: \in [batch_size], for every sent w\ PA number of true antecedents :return: list of size 10 """ precisions = [] for i in range(n): precision = 0 for k, item in enumerate(test_scores): ranks = len(item) - rankdata(item, method='ordinal').astype(int) precision += min(1, len(set(ranks[:num_true[k]]) & set(range(i)))) print num_true[k] print ranks precision /= float(len(test_scores)) precision *= 100 precisions.append(precision) return precisions
def precision_n(test_scores, num_true, n): """ Precision at n measure is the number of instances where the any crowd's answer occur within ranker's firs n choices For more details take a look at: http://www.aclweb.org/anthology/D13-1030 The first num_true_antec[i] dev_scores are predicted scores for true antecedents of the i-th sentence w/ PA :param test_scores: \in [batch_size, num of candidates], for every sent w\ PA predicted scores for its candidates :param num_true_antec: \in [batch_size], for every sent w\ PA number of true antecedents :return: list of size 10 """ precisions = [] for i in range(n): precision = 0 for k, item in enumerate(test_scores): ranks = len(item) - rankdata(item, method='ordinal').astype(int) precision += min(1, len(set(ranks[:i+1]) & set(range(num_true[k])))) precision /= float(len(test_scores)) precision *= 100 precisions.append(precision) return precisions
def precision_n(test_scores, num_true, n): """ Precision at n measure is the number of instances where the any crowd's answer occur within ranker's firs n choices For more details take a look at: http://www.aclweb.org/anthology/D13-1030 The first num_true_antec[i] dev_scores are predicted scores for true antecedents of the i-th sentence w/ PA :param test_scores: \in [batch_size, num of candidates], for every sent w\ PA predicted scores for its candidates :param num_true_antec: \in [batch_size], for every sent w\ PA number of true antecedents :return: list of size 10 """ precisions = [] for i in range(n): precision = 0 for k, item in enumerate(test_scores): ranks = len(item) - rankdata(item, method='ordinal').astype(int) precision += min(1, len(set(ranks[:num_true[k]]) & set(range(i+1)))) precision /= float(len(test_scores)) precision *= 100 precisions.append(precision) return precisions
def compute(self, today, assets, out, close, returns): v000 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v000000 = returns[-i0] v000001 = np.full(out.shape[0], 0.0) v00000 = v000000 < v000001 v000010 = np.empty((20, out.shape[0])) for i1 in range(1, 21): v000010[-i1] = returns[- i0 -i1] v00001 = np.std(v000010, axis=0) v00002 = close[-i0] v0000lgcl = np.empty(out.shape[0]) v0000lgcl[v00000] = v00001[v00000] v0000lgcl[~v00000] = v00002[~v00000] v0000 = v0000lgcl v0001 = np.full(out.shape[0], 2.0) v000[-i0] = np.power(v0000, v0001) v00 = np.argmax(v000, axis=0) v0 = stats.rankdata(v00) v1 = np.full(out.shape[0], 0.5) out[:] = v0 - v1 # (-1 * correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6))
def compute(self, today, assets, out, volume, close, open): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((6, out.shape[0])) for i0 in range(1, 7): v1000 = np.empty((3, out.shape[0])) for i1 in range(1, 4): v10000 = volume[- i0 -i1] v1000[-i1] = np.log(v10000) v100 = v1000[-1] - v1000[-3] v10[-i0] = stats.rankdata(v100) v11 = np.empty((6, out.shape[0])) for i0 in range(1, 7): v11000 = close[-i0] v11001 = open[-i0] v1100 = v11000 - v11001 v1101 = open[-i0] v110 = v1100 / v1101 v11[-i0] = stats.rankdata(v110) v1 = pd.DataFrame(v10).rolling(window=6).corr(pd.DataFrame(v11)).tail(1).as_matrix()[-1] out[:] = v0 * v1 # (-1 * correlation(rank(open), rank(volume), 10))
def compute(self, today, assets, out, close, open, vwap): v000 = open[-1] v00100 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v00100[-i0] = vwap[-i0] v0010 = v00100.sum(axis=0) v0011 = np.full(out.shape[0], 10.0) v001 = v0010 / v0011 v00 = v000 - v001 v0 = stats.rankdata(v00) v10 = np.full(out.shape[0], -1.0) v11000 = close[-1] v11001 = vwap[-1] v1100 = v11000 - v11001 v110 = stats.rankdata(v1100) v11 = np.abs(v110) v1 = v10 * v11 out[:] = v0 * v1 # (-1 * correlation(open, volume, 10))
def compute(self, today, assets, out, volume, close, vwap): v0000 = np.empty((3, out.shape[0])) for i0 in range(1, 4): v00000 = vwap[-i0] v00001 = close[-i0] v0000[-i0] = v00000 - v00001 v000 = np.max(v0000, axis=0) v00 = stats.rankdata(v000) v0100 = np.empty((3, out.shape[0])) for i0 in range(1, 4): v01000 = vwap[-i0] v01001 = close[-i0] v0100[-i0] = v01000 - v01001 v010 = np.min(v0100, axis=0) v01 = stats.rankdata(v010) v0 = v00 + v01 v100 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v100[-i0] = volume[-i0] v10 = v100[-1] - v100[-4] v1 = stats.rankdata(v10) out[:] = v0 * v1 # (sign(delta(volume, 1)) * (-1 * delta(close, 1)))
def compute(self, today, assets, out, volume, returns, open): v00 = np.full(out.shape[0], -1.0) v0100 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v0100[-i0] = returns[-i0] v010 = v0100[-1] - v0100[-4] v01 = stats.rankdata(v010) v0 = v00 * v01 v10 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v10[-i0] = open[-i0] v11 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v11[-i0] = volume[-i0] v1 = pd.DataFrame(v10).rolling(window=10).corr(pd.DataFrame(v11)).tail(1).as_matrix()[-1] out[:] = v0 * v1 # (-1 * sum(rank(correlation(rank(high), rank(volume), 3)), 3))
def compute(self, today, assets, out, high, volume): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((3, out.shape[0])) for i0 in range(1, 4): v1000 = np.empty((3, out.shape[0])) for i1 in range(1, 4): v10000 = high[- i0 -i1] v1000[-i1] = stats.rankdata(v10000) v1001 = np.empty((3, out.shape[0])) for i1 in range(1, 4): v10010 = volume[- i0 -i1] v1001[-i1] = stats.rankdata(v10010) v100 = pd.DataFrame(v1000).rolling(window=3).corr(pd.DataFrame(v1001)).tail(1).as_matrix()[-1] v10[-i0] = stats.rankdata(v100) v1 = v10.sum(axis=0) out[:] = v0 * v1 # (-1 * rank(covariance(rank(high), rank(volume), 5)))
def compute(self, today, assets, out, close, open): v0 = np.full(out.shape[0], -1.0) v10000 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1000000 = close[-i0] v1000001 = open[-i0] v100000 = v1000000 - v1000001 v10000[-i0] = np.abs(v100000) v1000 = np.std(v10000, axis=0) v10010 = close[-1] v10011 = open[-1] v1001 = v10010 - v10011 v100 = v1000 + v1001 v1010 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v1010[-i0] = close[-i0] v1011 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v1011[-i0] = open[-i0] v101 = pd.DataFrame(v1010).rolling(window=10).corr(pd.DataFrame(v1011)).tail(1).as_matrix()[-1] v10 = v100 + v101 v1 = stats.rankdata(v10) out[:] = v0 * v1 # ((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) * (1 + rank((1 + sum(returns, 250)))))
def compute(self, today, assets, out, close, returns): v00 = np.full(out.shape[0], -1.0) v01000 = close[-1] v010010 = close[-8] v01001 = v010010 # delay v0100 = v01000 - v01001 v01010 = np.empty((8, out.shape[0])) for i0 in range(1, 9): v01010[-i0] = close[-i0] v0101 = v01010[-1] - v01010[-8] v010 = v0100 + v0101 v01 = np.sign(v010) v0 = v00 * v01 v10 = np.full(out.shape[0], 1.0) v1100 = np.full(out.shape[0], 1.0) v11010 = np.empty((250, out.shape[0])) for i0 in range(1, 251): v11010[-i0] = returns[-i0] v1101 = v11010.sum(axis=0) v110 = v1100 + v1101 v11 = stats.rankdata(v110) v1 = v10 + v11 out[:] = v0 * v1 # (((-1 * rank((open - delay(high, 1)))) * rank((open - delay(close, 1)))) * rank((open - delay(low, 1))))
def compute(self, today, assets, out, high, close, open, low): v000 = np.full(out.shape[0], -1.0) v00100 = open[-1] v001010 = high[-2] v00101 = v001010 # delay v0010 = v00100 - v00101 v001 = stats.rankdata(v0010) v00 = v000 * v001 v0100 = open[-1] v01010 = close[-2] v0101 = v01010 # delay v010 = v0100 - v0101 v01 = stats.rankdata(v010) v0 = v00 * v01 v100 = open[-1] v1010 = low[-2] v101 = v1010 # delay v10 = v100 - v101 v1 = stats.rankdata(v10) out[:] = v0 * v1 # ((((sum(close, 8) / 8) + stddev(close, 8)) < (sum(close, 2) / 2)) ? (-1 * 1) : (((sum(close, 2) / 2) < ((sum(close, 8) / 8) - stddev(close, 8))) ? 1 : (((1 < (volume / adv20)) || ((volume / adv20) == 1)) ? 1 : (-1 * 1))))
def compute(self, today, assets, out, high, volume, close): v0 = np.full(out.shape[0], -1.0) v100 = np.empty((6, out.shape[0])) for i0 in range(1, 7): v1000 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v1000[-i1] = high[- i0 -i1] v1001 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v1001[-i1] = volume[- i0 -i1] v100[-i0] = pd.DataFrame(v1000).rolling(window=5).corr(pd.DataFrame(v1001)).tail(1).as_matrix()[-1] v10 = v100[-1] - v100[-6] v1100 = np.empty((20, out.shape[0])) for i0 in range(1, 21): v1100[-i0] = close[-i0] v110 = np.std(v1100, axis=0) v11 = stats.rankdata(v110) v1 = v10 * v11 out[:] = v0 * v1 # (((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0)
def compute(self, today, assets, out, close, open): v000 = np.empty((200, out.shape[0])) for i0 in range(1, 201): v00000 = open[-2] v00001 = close[-2] v0000 = v00000 - v00001 v000[-i0] = v0000 # delay v001 = np.empty((200, out.shape[0])) for i0 in range(1, 201): v001[-i0] = close[-i0] v00 = pd.DataFrame(v000).rolling(window=200).corr(pd.DataFrame(v001)).tail(1).as_matrix()[-1] v0 = stats.rankdata(v00) v100 = open[-1] v101 = close[-1] v10 = v100 - v101 v1 = stats.rankdata(v10) out[:] = v0 + v1 # ((-1 * rank(Ts_Rank(close, 10))) * rank((close / open)))
def compute(self, today, assets, out, high, volume): v00 = np.full(out.shape[0], -1.0) v0100 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v0100[-i0] = high[-i0] v010 = np.std(v0100, axis=0) v01 = stats.rankdata(v010) v0 = v00 * v01 v10 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v10[-i0] = high[-i0] v11 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v11[-i0] = volume[-i0] v1 = pd.DataFrame(v10).rolling(window=10).corr(pd.DataFrame(v11)).tail(1).as_matrix()[-1] out[:] = v0 * v1 # (((high * low)^0.5) - vwap)
def compute(self, today, assets, out, volume, vwap): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1000 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v10000 = volume[-i0 - i1] v1000[-i1] = stats.rankdata(v10000) v1001 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v10010 = vwap[-i0 - i1] v1001[-i1] = stats.rankdata(v10010) v100 = pd.DataFrame(v1000).rolling(window=5).corr(pd.DataFrame(v1001)).tail(1).as_matrix()[-1] v10[-i0] = stats.rankdata(v100) v1 = np.max(v10, axis=0) out[:] = v0 * v1 # (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 * 0.05)) ? 1 : ((-1 * 1) * (close - delay(close, 1))))
def compute(self, today, assets, out, returns): v0 = np.full(out.shape[0], 0.0) v10 = np.full(out.shape[0], 1.0) v110000 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v110000[-i0] = returns[-i0] v11000 = v110000.sum(axis=0) v110010 = np.empty((3, out.shape[0])) for i0 in range(1, 4): v1100100 = np.empty((2, out.shape[0])) for i1 in range(1, 3): v1100100[-i1] = returns[-i0 - i1] v110010[-i0] = v1100100.sum(axis=0) v11001 = v110010.sum(axis=0) v1100 = v11000 / v11001 v110 = stats.rankdata(v1100) v11100 = returns[-1] v11101 = cap[-1] v1110 = v11100 * v11101 v111 = stats.rankdata(v1110) v11 = v110 * v111 v1 = v10 * v11 out[:] = v0 - v1 # (0 - (1 * ((close - vwap) / decay_linear(rank(ts_argmax(close, 30)), 2))))
def compute(self, today, assets, out, close, vwap): v0 = np.full(out.shape[0], 0.0) v10 = np.full(out.shape[0], 1.0) v1100 = close[-1] v1101 = vwap[-1] v110 = v1100 - v1101 v1110 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v111000 = np.empty((30, out.shape[0])) for i1 in range(1, 31): v111000[-i1] = close[-i0 - i1] v11100 = np.argmax(v111000, axis=0) v1110[-i0] = stats.rankdata(v11100) v111 = (v1110 * (np.arange(1.0, 3, 1.0) / 3)[:, np.newaxis]).sum(axis=0) # decay_linear v11 = v110 / v111 v1 = v10 * v11 out[:] = v0 - v1
def compute(self, today, assets, out, adv180, vwap): v000 = vwap[-1] v0010 = np.empty((16, out.shape[0])) for i0 in range(1, 17): v0010[-i0] = vwap[-i0] v001 = np.min(v0010, axis=0) v00 = v000 - v001 v0 = stats.rankdata(v00) v100 = np.empty((18, out.shape[0])) for i0 in range(1, 19): v100[-i0] = vwap[-i0] v101 = np.empty((18, out.shape[0])) for i0 in range(1, 19): v101[-i0] = adv180[-i0] v10 = pd.DataFrame(v100).rolling(window=18).corr(pd.DataFrame(v101)).tail(1).as_matrix()[-1] v1 = stats.rankdata(v10) out[:] = v0 < v1 # ((rank(correlation(vwap, sum(adv20, 22.4101), 9.91009)) < rank(((rank(open) + rank(open)) < (rank(((high + low) / 2)) + rank(high))))) * -1)
def compute(self, today, assets, out, volume, adv50, low, vwap): v000 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v000[-i0] = vwap[-i0] v001 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v001[-i0] = volume[-i0] v00 = pd.DataFrame(v000).rolling(window=4).corr(pd.DataFrame(v001)).tail(1).as_matrix()[-1] v0 = stats.rankdata(v00) v100 = np.empty((12, out.shape[0])) for i0 in range(1, 13): v1000 = low[-i0] v100[-i0] = stats.rankdata(v1000) v101 = np.empty((12, out.shape[0])) for i0 in range(1, 13): v1010 = adv50[-i0] v101[-i0] = stats.rankdata(v1010) v10 = pd.DataFrame(v100).rolling(window=12).corr(pd.DataFrame(v101)).tail(1).as_matrix()[-1] v1 = stats.rankdata(v10) out[:] = v0 < v1
def compute(self, today, assets, out, close, adv20, vwap, open): v000 = np.empty((20, out.shape[0])) for i0 in range(1, 21): v0000 = np.empty((6, out.shape[0])) for i1 in range(1, 7): v0000[-i1] = close[-i0 - i1] v0001 = np.empty((6, out.shape[0])) for i1 in range(1, 7): v00010 = np.empty((15, out.shape[0])) for i2 in range(1, 16): v00010[-i2] = adv20[-i0 - i1 - i2] v0001[-i1] = v00010.sum(axis=0) v000[-i0] = pd.DataFrame(v0000).rolling(window=6).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00 = pd.DataFrame(v000).rank().tail(1).as_matrix()[-1] v01000 = open[-1] v01001 = close[-1] v0100 = v01000 + v01001 v01010 = vwap[-1] v01011 = open[-1] v0101 = v01010 + v01011 v010 = v0100 - v0101 v01 = stats.rankdata(v010) v0 = v00 < v01 v1 = np.full(out.shape[0], -1.0) out[:] = v0 * v1
def test_rank_methods_series(self): tm.skip_if_no_package('scipy', '0.13', 'scipy.stats.rankdata') import scipy from scipy.stats import rankdata xs = np.random.randn(9) xs = np.concatenate([xs[i:] for i in range(0, 9, 2)]) # add duplicates np.random.shuffle(xs) index = [chr(ord('a') + i) for i in range(len(xs))] for vals in [xs, xs + 1e6, xs * 1e-6]: ts = Series(vals, index=index) for m in ['average', 'min', 'max', 'first', 'dense']: result = ts.rank(method=m) sprank = rankdata(vals, m if m != 'first' else 'ordinal') expected = Series(sprank, index=index) if LooseVersion(scipy.__version__) >= '0.17.0': expected = expected.astype('float64') tm.assert_series_equal(result, expected)
def make_submit(self, model, submit_file): data = self.eval_sets().values()[0] target_lines = list() answers = np.asarray([[idx] for idx in self.entity.keys()]) for i, d in enumerate(data): num_candidate = len(self.entity) index_entities = xrange(num_candidate) terms = d.split('\t') subjects = np.asarray([[terms[0]]] * num_candidate) relations = np.asarray([[terms[1]]] * num_candidate) sims = model.predict([subjects, relations, answers], batch_size=num_candidate).flatten() print(i) r = rankdata(sims, method='ordinal') index_candidates = nlargest(200, index_entities, key=lambda j: r[j]) one_line = ' '.join([str(index_candidate) for index_candidate in index_candidates]) target_lines.append(one_line + '\n') submit_file.writelines(target_lines)
def make_submit_rt(self, model, submit_file): data = self.eval_sets_rt().values()[0] target_lines = list() answers = np.asarray([[idx] for idx in self.entity.keys()]) for i, d in enumerate(data): num_candidate = len(self.entity) index_entities = xrange(num_candidate) terms = d.split('\t') relations = np.asarray([[terms[0]]] * num_candidate) objects = np.asarray([[terms[1]]] * num_candidate) sims = model.predict_rt([answers, relations, objects], batch_size=num_candidate).flatten() print(i) r = rankdata(sims, method='ordinal') index_candidates = nlargest(200, index_entities, key=lambda j: r[j]) one_line = ' '.join([str(index_candidate) for index_candidate in index_candidates]) target_lines.append(one_line + '\n') submit_file.writelines(target_lines)
def arrau_precision_n(test_scores, num_true, all_candidates, punctuation_ids, ns): """ Precision at n measure is the number of instances where the any crowd's answer occur within ranker's firs n choices For more details take a look at: http://www.aclweb.org/anthology/D13-1030 The first num_true_antec[i] dev_scores are predicted scores for true antecedents of the i-th sentence w/ PA :param test_scores: \in [batch_size, num of candidates], for every sent w\ PA predicted scores for its candidates :param num_true_antec: \in [batch_size], for every sent w\ PA number of true antecedents :return: list of size 10 """ precisions = [] for i in range(ns): precision = 0 for k, item in enumerate(test_scores): ranks = len(item) - rankdata(item, method='ordinal').astype(int) #precision += min(1, len(set(ranks[:i+1]) & set(range(num_true)))) counter = 0 for pred in ranks[:i+1]: for gold in range(num_true[k]): sym_difference = list(set(all_candidates[k][pred]) ^ set(all_candidates[k][gold])) intersection_strip = [s for s in sym_difference if s not in punctuation_ids] if len(intersection_strip) <= 1: counter += 1 precision += min(1, counter) precision /= float(len(test_scores)) precision *= 100 precisions.append(precision) return precisions
def preprocess(self, x, fit=False): """Transform each marginal to be as close to a standard Gaussian as possible. 'standard' (default) just subtracts the mean and scales by the std. 'empirical' does an empirical gaussianization (but this cannot be inverted). 'outliers' tries to squeeze in the outliers Any other choice will skip the transformation.""" if self.missing_values is not None: x, self.n_obs = mean_impute(x, self.missing_values) # Creates a copy else: self.n_obs = len(x) if self.gaussianize == 'none': pass elif self.gaussianize == 'standard': if fit: mean = np.mean(x, axis=0) # std = np.std(x, axis=0, ddof=0).clip(1e-10) std = np.sqrt(np.sum((x - mean)**2, axis=0) / self.n_obs).clip(1e-10) self.theta = (mean, std) x = ((x - self.theta[0]) / self.theta[1]) if np.max(np.abs(x)) > 6 and self.verbose: print("Warning: outliers more than 6 stds away from mean. Consider using gaussianize='outliers'") elif self.gaussianize == 'outliers': if fit: mean = np.mean(x, axis=0) std = np.std(x, axis=0, ddof=0).clip(1e-10) self.theta = (mean, std) x = g((x - self.theta[0]) / self.theta[1]) # g truncates long tails elif self.gaussianize == 'empirical': print("Warning: correct inversion/transform of empirical gauss transform not implemented.") x = np.array([norm.ppf((rankdata(x_i) - 0.5) / len(x_i)) for x_i in x.T]).T if self.gpu and fit: # Don't return GPU matrices when only transforming x = cm.CUDAMatrix(x) return x
def compute(self, today, assets, out, volume, open): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v100 = open[-i0] v10[-i0] = stats.rankdata(v100) v11 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v110 = volume[-i0] v11[-i0] = stats.rankdata(v110) v1 = pd.DataFrame(v10).rolling(window=10).corr(pd.DataFrame(v11)).tail(1).as_matrix()[-1] out[:] = v0 * v1 # (-1 * Ts_Rank(rank(low), 9))
def compute(self, today, assets, out, low): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((9, out.shape[0])) for i0 in range(1, 10): v100 = low[-i0] v10[-i0] = stats.rankdata(v100) v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1] out[:] = v0 * v1 # (rank((open - (sum(vwap, 10) / 10))) * (-1 * abs(rank((close - vwap)))))
def compute(self, today, assets, out, volume, close): v0 = np.full(out.shape[0], -1.0) v100 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1000 = close[-i0] v100[-i0] = stats.rankdata(v1000) v101 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1010 = volume[-i0] v101[-i0] = stats.rankdata(v1010) v10 = pd.DataFrame(v100).rolling(window=5).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1] v1 = stats.rankdata(v10) out[:] = v0 * v1 # ((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10))
def compute(self, today, assets, out, volume, close, adv20): v000 = np.full(out.shape[0], -1.0) v00100 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v00100[-i0] = close[-i0] v0010 = pd.DataFrame(v00100).rank().tail(1).as_matrix()[-1] v001 = stats.rankdata(v0010) v00 = v000 * v001 v0100 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v01000 = np.empty((2, out.shape[0])) for i1 in range(1, 3): v01000[-i1] = close[- i0 -i1] v0100[-i0] = v01000[-1] - v01000[-2] v010 = v0100[-1] - v0100[-2] v01 = stats.rankdata(v010) v0 = v00 * v01 v100 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1000 = volume[-i0] v1001 = adv20[-i0] v100[-i0] = v1000 / v1001 v10 = pd.DataFrame(v100).rank().tail(1).as_matrix()[-1] v1 = stats.rankdata(v10) out[:] = v0 * v1 # (-1 * rank(((stddev(abs((close - open)), 5) + (close - open)) + correlation(close, open, 10))))
def compute(self, today, assets, out, volume, vwap): v00 = np.full(out.shape[0], 0.5) v01000 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v010000 = np.empty((6, out.shape[0])) for i1 in range(1, 7): v0100000 = volume[-i0-i1] v010000[-i1] = stats.rankdata(v0100000) v010001 = np.empty((6, out.shape[0])) for i1 in range(1, 7): v0100010 = vwap[-i0-i1] v010001[-i1] = stats.rankdata(v0100010) v01000[-i0] = pd.DataFrame(v010000).rolling(window=6).corr(pd.DataFrame(v010001)).tail(1).as_matrix()[-1] v0100 = v01000.sum(axis=0) v0101 = np.full(out.shape[0], 2.0) v010 = v0100 / v0101 v01 = stats.rankdata(v010) v0 = v00 < v01 v10 = np.full(out.shape[0], -1.0) v11 = np.full(out.shape[0], 1.0) v1 = v10 * v11 v2 = np.full(out.shape[0], 1.0) vlgcl = np.empty(out.shape[0]) vlgcl[v0] = v1[v0] vlgcl[~v0] = 1 out[:] = vlgcl # scale(((correlation(adv20, low, 5) + ((high + low) / 2)) - close))
def compute(self, today, assets, out, close, returns): v000 = np.empty((1, out.shape[0])) for i0 in range(1, 2): v00000000 = np.empty((1, out.shape[0])) for i1 in range(1, 2): v000000000 = np.empty((2, out.shape[0])) for i2 in range(1, 3): v000000000000 = np.full(out.shape[0], -1.0) v00000000000100 = np.empty((6, out.shape[0])) for i3 in range(1, 7): v000000000001000 = close[-i0 - i1 - i2 - i3] v000000000001001 = np.full(out.shape[0], 1.0) v00000000000100[-i3] = v000000000001000 - v000000000001001 v0000000000010 = v00000000000100[-1] - v00000000000100[-6] v000000000001 = stats.rankdata(v0000000000010) v00000000000 = v000000000000 * v000000000001 v0000000000 = stats.rankdata(v00000000000) v000000000[-i2] = stats.rankdata(v0000000000) v00000000[-i1] = np.min(v000000000, axis=0) v0000000 = v00000000.sum(axis=0) v000000 = np.log(v0000000) v00000 = v000000 / np.abs(v000000).sum() v0000 = stats.rankdata(v00000) v000[-i0] = stats.rankdata(v0000) v00 = np.prod(v000, axis=0) v01 = np.full(out.shape[0], 5.0) v0 = np.minimum(v00, v01) v10 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v1000 = np.full(out.shape[0], -1.0) v1001 = returns[-7] v100 = v1000 * v1001 v10[-i0] = v100 # delay v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1] out[:] = v0 + v1 # (((1.0 - rank(((sign((close - delay(close, 1))) + sign((delay(close, 1) - delay(close, 2)))) + sign((delay(close, 2) - delay(close, 3)))))) * sum(volume, 5)) / sum(volume, 20))
def compute(self, today, assets, out, volume, close): v000 = np.full(out.shape[0], 1.0) v00100000 = close[-1] v001000010 = close[-2] v00100001 = v001000010 # delay v0010000 = v00100000 - v00100001 v001000 = np.sign(v0010000) v001001000 = close[-2] v00100100 = v001001000 # delay v001001010 = close[-3] v00100101 = v001001010 # delay v0010010 = v00100100 - v00100101 v001001 = np.sign(v0010010) v00100 = v001000 + v001001 v00101000 = close[-3] v0010100 = v00101000 # delay v00101010 = close[-4] v0010101 = v00101010 # delay v001010 = v0010100 - v0010101 v00101 = np.sign(v001010) v0010 = v00100 + v00101 v001 = stats.rankdata(v0010) v00 = v000 - v001 v010 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v010[-i0] = volume[-i0] v01 = v010.sum(axis=0) v0 = v00 * v01 v10 = np.empty((20, out.shape[0])) for i0 in range(1, 21): v10[-i0] = volume[-i0] v1 = v10.sum(axis=0) out[:] = v0 / v1 # ((rank(rank(rank(decay_linear((-1 * rank(rank(delta(close, 10)))), 10)))) + rank((-1 * delta(close, 3)))) + sign(scale(correlation(adv20, low, 12))))
def compute(self, today, assets, out, close, adv20, low): v000000 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v0000000 = np.full(out.shape[0], -1.0) v0000001000 = np.empty((11, out.shape[0])) for i1 in range(1, 12): v0000001000[-i1] = close[-i0 - i1] v000000100 = v0000001000[-1] - v0000001000[-11] v00000010 = stats.rankdata(v000000100) v0000001 = stats.rankdata(v00000010) v000000[-i0] = v0000000 * v0000001 v00000 = (v000000 * (np.arange(1.0, 11, 1.0) / 55)[:, np.newaxis]).sum(axis=0) # decay_linear v0000 = stats.rankdata(v00000) v000 = stats.rankdata(v0000) v00 = stats.rankdata(v000) v0100 = np.full(out.shape[0], -1.0) v01010 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v01010[-i0] = close[-i0] v0101 = v01010[-1] - v01010[-4] v010 = v0100 * v0101 v01 = stats.rankdata(v010) v0 = v00 + v01 v1000 = np.empty((12, out.shape[0])) for i0 in range(1, 13): v1000[-i0] = adv20[-i0] v1001 = np.empty((12, out.shape[0])) for i0 in range(1, 13): v1001[-i0] = low[-i0] v100 = pd.DataFrame(v1000).rolling(window=12).corr(pd.DataFrame(v1001)).tail(1).as_matrix()[-1] v10 = v100 / np.abs(v100).sum() v1 = np.sign(v10) out[:] = v0 + v1 # (scale(((sum(close, 7) / 7) - close)) + (20 * scale(correlation(vwap, delay(close, 5), 230))))
def compute(self, today, assets, out, close, open): v00 = np.full(out.shape[0], -1.0) v0100 = np.full(out.shape[0], 1.0) v01010 = open[-1] v01011 = close[-1] v0101 = v01010 / v01011 v010 = v0100 - v0101 v011 = np.full(out.shape[0], 1.0) v01 = np.power(v010, v011) v0 = v00 * v01 out[:] = stats.rankdata(v0) # rank(((1 - rank((stddev(returns, 2) / stddev(returns, 5)))) + (1 - rank(delta(close, 1)))))
def compute(self, today, assets, out, close, open): v00 = np.full(out.shape[0], -1.0) v0100 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v0100[-i0] = close[-i0] v010 = pd.DataFrame(v0100).rank().tail(1).as_matrix()[-1] v01 = stats.rankdata(v010) v0 = v00 * v01 v100 = close[-1] v101 = open[-1] v10 = v100 / v101 v1 = stats.rankdata(v10) out[:] = v0 * v1 # ((-1 * rank((delta(close, 7) * (1 - rank(decay_linear((volume / adv20), 9)))))) * (1 + rank(sum(returns, 250))))
def compute(self, today, assets, out, volume, close, returns, adv20): v00 = np.full(out.shape[0], -1.0) v01000 = np.empty((8, out.shape[0])) for i0 in range(1, 9): v01000[-i0] = close[-i0] v0100 = v01000[-1] - v01000[-8] v01010 = np.full(out.shape[0], 1.0) v0101100 = np.empty((9, out.shape[0])) for i0 in range(1, 10): v01011000 = volume[-i0] v01011001 = adv20[-i0] v0101100[-i0] = v01011000 / v01011001 v010110 = (v0101100 * (np.arange(1.0, 10, 1.0) / 45)[:, np.newaxis]).sum(axis=0) # decay_linear v01011 = stats.rankdata(v010110) v0101 = v01010 - v01011 v010 = v0100 * v0101 v01 = stats.rankdata(v010) v0 = v00 * v01 v10 = np.full(out.shape[0], 1.0) v1100 = np.empty((250, out.shape[0])) for i0 in range(1, 251): v1100[-i0] = returns[-i0] v110 = v1100.sum(axis=0) v11 = stats.rankdata(v110) v1 = v10 + v11 out[:] = v0 * v1 # ((-1 * rank(stddev(high, 10))) * correlation(high, volume, 10))
def compute(self, today, assets, out, high, volume): v0 = np.full(out.shape[0], -1.0) v10 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v10[-i0] = high[-i0] v11 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v110 = volume[-i0] v11[-i0] = stats.rankdata(v110) v1 = pd.DataFrame(v10).rolling(window=5).corr(pd.DataFrame(v11)).tail(1).as_matrix()[-1] out[:] = v0 * v1 # (-1 * ((rank((sum(delay(close, 5), 20) / 20)) * correlation(close, volume, 2)) * rank(correlation(sum(close, 5), sum(close, 20), 2))))
def compute(self, today, assets, out, volume, close): v0 = np.full(out.shape[0], -1.0) v100000 = np.empty((20, out.shape[0])) for i0 in range(1, 21): v1000000 = close[-6] v100000[-i0] = v1000000 # delay v10000 = v100000.sum(axis=0) v10001 = np.full(out.shape[0], 20.0) v1000 = v10000 / v10001 v100 = stats.rankdata(v1000) v1010 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v1010[-i0] = close[-i0] v1011 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v1011[-i0] = volume[-i0] v101 = pd.DataFrame(v1010).rolling(window=2).corr(pd.DataFrame(v1011)).tail(1).as_matrix()[-1] v10 = v100 * v101 v1100 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v11000 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v11000[-i1] = close[-i0 - i1] v1100[-i0] = v11000.sum(axis=0) v1101 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v11010 = np.empty((20, out.shape[0])) for i1 in range(1, 21): v11010[-i1] = close[-i0 - i1] v1101[-i0] = v11010.sum(axis=0) v110 = pd.DataFrame(v1100).rolling(window=2).corr(pd.DataFrame(v1101)).tail(1).as_matrix()[-1] v11 = stats.rankdata(v110) v1 = v10 * v11 out[:] = v0 * v1 # ((0.25 < (((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10))) ? (-1 * 1) : (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < 0) ? 1 : ((-1 * 1) * (close - delay(close, 1)))))
def compute(self, today, assets, out, volume, close, high, adv20, vwap): v000000 = np.full(out.shape[0], 1.0) v000001 = close[-1] v00000 = v000000 / v000001 v0000 = stats.rankdata(v00000) v0001 = volume[-1] v000 = v0000 * v0001 v001 = adv20[-1] v00 = v000 / v001 v0100 = high[-1] v010100 = high[-1] v010101 = close[-1] v01010 = v010100 - v010101 v0101 = stats.rankdata(v01010) v010 = v0100 * v0101 v01100 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v01100[-i0] = high[-i0] v0110 = v01100.sum(axis=0) v0111 = np.full(out.shape[0], 5.0) v011 = v0110 / v0111 v01 = v010 / v011 v0 = v00 * v01 v100 = vwap[-1] v1010 = vwap[-6] v101 = v1010 # delay v10 = v100 - v101 v1 = stats.rankdata(v10) out[:] = v0 - v1 # (indneutralize(((correlation(delta(close, 1), delta(delay(close, 1), 1), 250) * delta(close, 1)) / close), IndClass.subindustry) / sum(((delta(close, 1) / delay(close, 1))^2), 250))
def compute(self, today, assets, out, volume, returns, low): v0000 = np.full(out.shape[0], -1.0) v00010 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v00010[-i0] = low[-i0] v0001 = np.min(v00010, axis=0) v000 = v0000 * v0001 v00100 = np.empty((5, out.shape[0])) for i0 in range(6, 11): v00100[5 - i0] = low[-i0] v0010 = np.min(v00100, axis=0) v001 = v0010 # delay v00 = v000 + v001 v010000 = np.empty((240, out.shape[0])) for i0 in range(1, 241): v010000[-i0] = returns[-i0] v01000 = v010000.sum(axis=0) v010010 = np.empty((20, out.shape[0])) for i0 in range(1, 21): v010010[-i0] = returns[-i0] v01001 = v010010.sum(axis=0) v0100 = v01000 - v01001 v0101 = np.full(out.shape[0], 220.0) v010 = v0100 / v0101 v01 = stats.rankdata(v010) v0 = v00 * v01 v10 = np.empty((5, out.shape[0])) for i0 in range(1, 6): v10[-i0] = volume[-i0] v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1] out[:] = v0 * v1 # (-1 * delta((((close - low) - (high - close)) / (close - low)), 9))
def compute(self, today, assets, out, high, close, low, volume): v0 = np.full(out.shape[0], 0.0) v10 = np.full(out.shape[0], 1.0) v1100 = np.full(out.shape[0], 2.0) v1101000000 = close[-1] v1101000001 = low[-1] v110100000 = v1101000000 - v1101000001 v1101000010 = high[-1] v1101000011 = close[-1] v110100001 = v1101000010 - v1101000011 v11010000 = v110100000 - v110100001 v110100010 = high[-1] v110100011 = low[-1] v11010001 = v110100010 - v110100011 v1101000 = v11010000 / v11010001 v1101001 = volume[-1] v110100 = v1101000 * v1101001 v11010 = stats.rankdata(v110100) v1101 = v11010 / np.abs(v11010).sum() v110 = v1100 * v1101 v111000 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v111000[-i0] = close[-i0] v11100 = np.argmax(v111000, axis=0) v1110 = stats.rankdata(v11100) v111 = v1110 / np.abs(v1110).sum() v11 = v110 - v111 v1 = v10 * v11 out[:] = v0 - v1 # (rank((vwap - ts_min(vwap, 16.1219))) < rank(correlation(vwap, adv180, 17.9282)))
def compute(self, today, assets, out, high, open, adv20, low, vwap): v0000 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v0000[-i0] = vwap[-i0] v0001 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v00010 = np.empty((22, out.shape[0])) for i1 in range(1, 23): v00010[-i1] = adv20[-i0 - i1] v0001[-i0] = v00010.sum(axis=0) v000 = pd.DataFrame(v0000).rolling(window=10).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00 = stats.rankdata(v000) v010000 = open[-1] v01000 = stats.rankdata(v010000) v010010 = open[-1] v01001 = stats.rankdata(v010010) v0100 = v01000 + v01001 v01010000 = high[-1] v01010001 = low[-1] v0101000 = v01010000 + v01010001 v0101001 = np.full(out.shape[0], 2.0) v010100 = v0101000 / v0101001 v01010 = stats.rankdata(v010100) v010110 = high[-1] v01011 = stats.rankdata(v010110) v0101 = v01010 + v01011 v010 = v0100 < v0101 v01 = stats.rankdata(v010) v0 = v00 < v01 v1 = np.full(out.shape[0], -1.0) out[:] = v0 * v1
def compute(self, today, assets, out, adv60, open, vwap): v0000 = np.empty((6, out.shape[0])) for i0 in range(1, 7): v000000 = open[-i0] v000001 = np.full(out.shape[0], 0.00817205) v00000 = v000000 * v000001 v000010 = vwap[-i0] v0000110 = np.full(out.shape[0], 1.0) v0000111 = np.full(out.shape[0], 0.00817205) v000011 = v0000110 - v0000111 v00001 = v000010 * v000011 v0000[-i0] = v00000 + v00001 v0001 = np.empty((6, out.shape[0])) for i0 in range(1, 7): v00010 = np.empty((9, out.shape[0])) for i1 in range(1, 10): v00010[-i1] = adv60[-i0 - i1] v0001[-i0] = v00010.sum(axis=0) v000 = pd.DataFrame(v0000).rolling(window=6).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00 = stats.rankdata(v000) v0100 = open[-1] v01010 = np.empty((14, out.shape[0])) for i0 in range(1, 15): v01010[-i0] = open[-i0] v0101 = np.min(v01010, axis=0) v010 = v0100 - v0101 v01 = stats.rankdata(v010) v0 = v00 < v01 v1 = np.full(out.shape[0], -1.0) out[:] = v0 * v1 # ((rank(decay_linear(delta(vwap, 3.51013), 7.23052)) + Ts_Rank(decay_linear(((((low * 0.96633) + (low * (1 - 0.96633))) - vwap) / (open - ((high + low) / 2))), 11.4157), 6.72611)) * -1)
def compute(self, today, assets, out, high, open, low, vwap): v0000 = np.empty((7, out.shape[0])) for i0 in range(1, 8): v00000 = np.empty((5, out.shape[0])) for i1 in range(1, 6): v00000[-i1] = vwap[-i0 - i1] v0000[-i0] = v00000[-1] - v00000[-5] v000 = (v0000 * (np.arange(1.0, 8, 1.0) / 28)[:, np.newaxis]).sum(axis=0) # decay_linear v00 = stats.rankdata(v000) v010 = np.empty((7, out.shape[0])) for i0 in range(1, 8): v0100 = np.empty((11, out.shape[0])) for i1 in range(1, 12): v01000000 = low[-i0 - i1] v01000001 = np.full(out.shape[0], 0.96633) v0100000 = v01000000 * v01000001 v01000010 = low[-i0 - i1] v010000110 = np.full(out.shape[0], 1.0) v010000111 = np.full(out.shape[0], 0.96633) v01000011 = v010000110 - v010000111 v0100001 = v01000010 * v01000011 v010000 = v0100000 + v0100001 v010001 = vwap[-i0 - i1] v01000 = v010000 - v010001 v010010 = open[-i0 - i1] v01001100 = high[-i0 - i1] v01001101 = low[-i0 - i1] v0100110 = v01001100 + v01001101 v0100111 = np.full(out.shape[0], 2.0) v010011 = v0100110 / v0100111 v01001 = v010010 - v010011 v0100[-i1] = v01000 / v01001 v010[-i0] = (v0100 * (np.arange(1.0, 12, 1.0) / 66)[:, np.newaxis]).sum(axis=0) # decay_linear v01 = pd.DataFrame(v010).rank().tail(1).as_matrix()[-1] v0 = v00 + v01 v1 = np.full(out.shape[0], -1.0) out[:] = v0 * v1
def compute(self, today, assets, out, high, adv15, low, close): v000 = np.empty((14, out.shape[0])) for i0 in range(1, 15): v0000 = np.empty((9, out.shape[0])) for i1 in range(1, 10): v00000 = high[-i0 - i1] v0000[-i1] = stats.rankdata(v00000) v0001 = np.empty((9, out.shape[0])) for i1 in range(1, 10): v00010 = adv15[-i0 - i1] v0001[-i1] = stats.rankdata(v00010) v000[-i0] = pd.DataFrame(v0000).rolling(window=9).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00 = pd.DataFrame(v000).rank().tail(1).as_matrix()[-1] v0100 = np.empty((2, out.shape[0])) for i0 in range(1, 3): v010000 = close[-i0] v010001 = np.full(out.shape[0], 0.518371) v01000 = v010000 * v010001 v010010 = low[-i0] v0100110 = np.full(out.shape[0], 1.0) v0100111 = np.full(out.shape[0], 0.518371) v010011 = v0100110 - v0100111 v01001 = v010010 * v010011 v0100[-i0] = v01000 + v01001 v010 = v0100[-1] - v0100[-2] v01 = stats.rankdata(v010) v0 = v00 < v01 v1 = np.full(out.shape[0], -1.0) out[:] = v0 * v1
def compute(self, today, assets, out, close, vwap, open, low, adv180): v00 = np.empty((16, out.shape[0])) for i0 in range(1, 17): v000 = np.empty((4, out.shape[0])) for i1 in range(1, 5): v0000 = np.empty((18, out.shape[0])) for i2 in range(1, 19): v00000 = np.empty((3, out.shape[0])) for i3 in range(1, 4): v00000[-i3] = close[-i0 - i1 - i2 - i3] v0000[-i2] = pd.DataFrame(v00000).rank().tail(1).as_matrix()[-1] v0001 = np.empty((18, out.shape[0])) for i2 in range(1, 19): v00010 = np.empty((12, out.shape[0])) for i3 in range(1, 13): v00010[-i3] = adv180[-i0 - i1 - i2 - i3] v0001[-i2] = pd.DataFrame(v00010).rank().tail(1).as_matrix()[-1] v000[-i1] = pd.DataFrame(v0000).rolling(window=18).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00[-i0] = (v000 * (np.arange(1.0, 5, 1.0) / 10)[:, np.newaxis]).sum(axis=0) # decay_linear v0 = pd.DataFrame(v00).rank().tail(1).as_matrix()[-1] v10 = np.empty((4, out.shape[0])) for i0 in range(1, 5): v100 = np.empty((16, out.shape[0])) for i1 in range(1, 17): v1000000 = low[-i0 - i1] v1000001 = open[-i0 - i1] v100000 = v1000000 + v1000001 v1000010 = vwap[-i0 - i1] v1000011 = vwap[-i0 - i1] v100001 = v1000010 + v1000011 v10000 = v100000 - v100001 v1000 = stats.rankdata(v10000) v1001 = np.full(out.shape[0], 2.0) v100[-i1] = np.power(v1000, v1001) v10[-i0] = (v100 * (np.arange(1.0, 17, 1.0) / 136)[:, np.newaxis]).sum(axis=0) # decay_linear v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1] out[:] = np.maximum(v0, v1) # (rank(decay_linear(correlation(((high + low) / 2), adv40, 8.93345), 10.1519)) / rank(decay_linear(correlation(Ts_Rank(vwap, 3.72469), Ts_Rank(volume, 18.5188), 6.86671), 2.95011)))
def compute(self, today, assets, out, high, volume, adv40, low, vwap): v000 = np.empty((10, out.shape[0])) for i0 in range(1, 11): v0000 = np.empty((9, out.shape[0])) for i1 in range(1, 10): v000000 = high[-i0 - i1] v000001 = low[-i0 - i1] v00000 = v000000 + v000001 v00001 = np.full(out.shape[0], 2.0) v0000[-i1] = v00000 / v00001 v0001 = np.empty((9, out.shape[0])) for i1 in range(1, 10): v0001[-i1] = adv40[-i0 - i1] v000[-i0] = pd.DataFrame(v0000).rolling(window=9).corr(pd.DataFrame(v0001)).tail(1).as_matrix()[-1] v00 = (v000 * (np.arange(1.0, 11, 1.0) / 55)[:, np.newaxis]).sum(axis=0) # decay_linear v0 = stats.rankdata(v00) v100 = np.empty((3, out.shape[0])) for i0 in range(1, 4): v1000 = np.empty((7, out.shape[0])) for i1 in range(1, 8): v10000 = np.empty((4, out.shape[0])) for i2 in range(1, 5): v10000[-i2] = vwap[-i0 - i1 - i2] v1000[-i1] = pd.DataFrame(v10000).rank().tail(1).as_matrix()[-1] v1001 = np.empty((7, out.shape[0])) for i1 in range(1, 8): v10010 = np.empty((19, out.shape[0])) for i2 in range(1, 20): v10010[-i2] = volume[-i0 - i1 - i2] v1001[-i1] = pd.DataFrame(v10010).rank().tail(1).as_matrix()[-1] v100[-i0] = pd.DataFrame(v1000).rolling(window=7).corr(pd.DataFrame(v1001)).tail(1).as_matrix()[-1] v10 = (v100 * (np.arange(1.0, 4, 1.0) / 6)[:, np.newaxis]).sum(axis=0) # decay_linear v1 = stats.rankdata(v10) out[:] = v0 / v1 # (max(rank(decay_linear(delta(vwap, 4.72775), 2.91864)), Ts_Rank(decay_linear(((delta(((open * 0.147155) + (low * (1 - 0.147155))), 2.03608) / ((open * 0.147155) + (low * (1 - 0.147155)))) * -1), 3.33829), 16.7411)) * -1)