def value_iteration(self, agent, max_iterator=-1): iteration = 0 while True: iteration += 1 new_value_pi = np.zeros_like(agent.value_pi) value_sas = [] for i in range(1, agent.s_len): for j in range(agent.a_len): value_sa = np.dot(agent.p[j, i, :], agent.r + agent.gamma * agent.value_pi) value_sas.append(value_sa) new_value_pi[i] = max(value_sas) diff = np.sqrt(np.sum(np.square(agent.value_pi - new_value_pi))) if diff < 1e-6: break else: agent.value_pi = new_value_pi if iteration == max_iterator: break print('Iteration converged at round %d' % iteration) for i in range(1, agent.s_len): for j in range(0, agent.a_len): agent.value_q[i, j] = np.dot( agent.p[i, j], agent.r + agent.gamma * agent.value_pi) max_act = np.argmax(agent.value_q[i, :]) agent.pi[i] = max_act
def fit(self, x, y, w=None): if w is None: w = np.ones(len(y)) / len(y) data = zip(x, y, w) data = sorted(data, key=lambda s: s[0]) [x, y, w] = zip(*data) y = np.array(y) w = np.array(w) correct = np.zeros((2, len(y))) # 0 row for x < v, 1 row for x >= v for i in range(len(y)): w_front = w[:i] w_back = w[i:] correct[0, i] += np.sum(w_front[y[:i] == 1]) + np.sum( w_back[y[i:] == -1]) correct[1, i] += np.sum(w_front[y[:i] == -1]) + np.sum( w_back[y[i:] == 1]) idx = np.argmax(correct, axis=1) if correct[0, int(idx[0])] > correct[1, int(idx[1])]: self.sign = "smaller" self.thres = x[idx[0]] else: self.sign = "equal to or bigger" self.thres = x[idx[1]]
def auto_corr(comp_vc, p_wf, t_wf): """Function computes the autocorrelation function from given vectors Args: wf_n(numpy array, complex): Wave function over time Returns: numpy array, complex: The autocorrelation function over time. """ # autocorrelation fuction ac_file = np.zeros([p_wf, t_wf + 1], dtype=np.complex_) for n in range(p_wf): ac_file[n] = np.sum(comp_vc[:, 0] * np.conjugate(comp_vc[:, n])) return ac_file
def fit(self, X, y, verbose=False): weights = np.ones(len(y)) / len( y) # initial the weights for each data sample accuracy = 0 epoch = 0 while 1 - accuracy > self.epsilon or epoch <= self.iters: # stop when acc is okay or epoch number is larger than iters epoch += 1 weak_learner = weak_learner_unit() alpha = AdaBoost.calcAlpha(weak_learner.score(X, y, weights)) self.alphas.append(alpha) self.weak_learners_list.append(weak_learner) # update the weights by w := weights = weights * np.exp(-alpha * y * self.predict(X)) weights = weights / np.sum(weights) accuracy = self.accuracy(X, y)
def getRetRange(rets, naLower, naUpper, naExpected="False", s_type="long"): """ @summary Returns the range of possible returns with upper and lower bounds on the portfolio participation @param rets: Expected returns @param naLower: List of lower percentages by stock @param naUpper: List of upper percentages by stock @return tuple containing (fMin, fMax) """ # Calculate theoretical minimum and maximum theoretical returns """ fMin = 0 fMax = 0 rets = deepcopy(rets) if naExpected == "False": naExpected = np.average(rets, axis=0) na_signs = np.sign(naExpected) indices, = np.where(na_signs == 0) na_signs[indices] = 1 if s_type == "long": na_signs = np.ones(len(na_signs)) elif s_type == "short": na_signs = np.ones(len(na_signs)) * (-1) rets = na_signs * rets naExpected = na_signs * naExpected naSortInd = naExpected.argsort() # First add the lower bounds on portfolio participation """ for i, fRet in enumerate(naExpected): fMin = fMin + fRet * naLower[i] fMax = fMax + fRet * naLower[i] # Now calculate minimum returns""" # allocate the max possible in worst performing equities """ # Subtract min since we have already counted it """ naUpperAdd = naUpper - naLower fTotalPercent = np.sum(naLower[:]) for i, lInd in enumerate(naSortInd): fRetAdd = naUpperAdd[lInd] * naExpected[lInd] fTotalPercent = fTotalPercent + naUpperAdd[lInd] fMin = fMin + fRetAdd # Check if this additional percent puts us over the limit """ if fTotalPercent > 1.0: fMin = fMin - naExpected[lInd] * (fTotalPercent - 1.0) break # Repeat for max, just reverse the sort, i.e. high to low """ naUpperAdd = naUpper - naLower fTotalPercent = np.sum(naLower[:]) for i, lInd in enumerate(naSortInd[::-1]): fRetAdd = naUpperAdd[lInd] * naExpected[lInd] fTotalPercent = fTotalPercent + naUpperAdd[lInd] fMax = fMax + fRetAdd # Check if this additional percent puts us over the limit """ if fTotalPercent > 1.0: fMax = fMax - naExpected[lInd] * (fTotalPercent - 1.0) break return (fMin, fMax)
''' numpy.sum函数和python的求和函数功能基本⼀致,但是还是有⼀些⼩区别: numpy的求和函数具有维度的概念,求和多项可以是数组 同时参数含义跟python的sum并不⼀致 numpy.sum速度快⼀些 ''' from numpy import np a = np.arange(100).reshape((10, 10)) b = np.sum(a) print(b)
def score(self, x, y, w=None): # the wrong percent if w is None: w = np.ones(len(y)) / len(y) return 1 - np.sum(w[self.predict(x) == y])
def accuracy(self, x, y): acc = np.sum(self.predict(x) == y) / len(y) return acc