def maxl2ct(matlist, zlist, epslist, oldequalities=None, oldinequalities=None, slack=1.0, filterfunction=None): """ find the smallest L_infty distance d between the OLS solution and a nonnegative solution. The find a nonnegative NNLS solution under the constraint that its distance from from the OLS solution is at most d + slack. filterfunction returns a set of matrices (queries) on which we do not want to differ significantly from OLS This only works if all queries are counting queries. """ if oldinequalities is None: oldinequalities = [] if oldequalities is None: oldequalities = [] # get least squares solution olsresult = ols(matlist, zlist, epslist, equalities=oldequalities, inequalities=oldinequalities) estx = olsresult.x # get query answers from least squares solution if filterfunction is None: newm = matlist[:] else: newm = filterfunction(matlist, zlist, epslist) newz = [np.maximum(0, m @ estx) for m in newm] queries = list(zip(newm, newz)) # do Linfinity nonnegative fit to least squares solution maxresult = fitter.fit(queries, bound=(0, None), lp=np.infty, equalities=oldequalities, inequalities=oldinequalities) # now add a slack to the distance to enlarge feasible set and break # ties based on least squares error to original queries. distance = maxresult.fun # value of objective function inequalities = [(m, z - slack - distance) for (m, z) in zip(newm, newz)] inequalities.extend([(-m, -z - slack - distance) for (m, z) in zip(newm, newz)]) inequalities.extend(oldinequalities) lastresult = fitter.fit(list(zip(matlist, zlist, [e * e for e in epslist])), equalities=oldequalities, inequalities=inequalities, bound=(0, None)) lastresult.success = lastresult.success and olsresult.success and maxresult.success return lastresult
def big_resolve(Alist, zlist, epslist, threshfunction, tol=0.001, domax=False, userb=False): todonow = [] todolater = [] for (A, z, eps) in zip(Alist, zlist, epslist): t = threshfunction(A, z, eps) numqueries = A.shape[0] belowmask = z <= t numbelow = belowmask.sum() if numbelow > 1: todolater.append((A[belowmask], z[belowmask], eps**2)) extraA = A[belowmask].sum(axis=0, keepdims=True) if not userb: extraZ = z[belowmask].sum(keepdims=True) else: myview = z[belowmask] rbconstant = rbgeo(eps) rbview = np.where(myview <= 0, rbconstant, myview) extraZ = rbview.sum(keepdims=True) neweight = (eps**2) / numbelow todonow.append((extraA, extraZ, neweight)) if numqueries > 0: todonow.append((A[np.logical_not(belowmask)], z[np.logical_not(belowmask)], eps**2)) firstnnls = fitter.fit(todonow, bound=(0, None)) if not domax else maxfit(todonow) if not firstnnls.success: print("big_resolve failed in first nnls") inequalities = [(T[0], (T[0] @ firstnnls.x) - tol) for T in todonow] inequalities.extend([(-T[0], -(T[0] @ firstnnls.x) - tol) for T in todonow]) if len(todolater) > 0: answer = fitter.fit(todolater, inequalities=inequalities, bound=(0, None)) if not domax else maxfit( todolater, inequalities=inequalities) for A, z in inequalities: assert np.all(A @ answer.x - z + tol >= 0) if not answer.success: print(f"Second NNLS for in big_resolve failed") answer.success = answer.success and firstnnls.success else: answer = firstnnls return answer
def altStrategy(y, matlist, zlist, epslist, sig_level=0.05): # This estimator is not defined when d = 1 if len(zlist) == 2: return nnls(matlist, zlist, epslist) elif len(zlist) == 4: d = 2 else: raise ("Cannot determine d") ns = [] assert all([k == epslist[0] for k in epslist]) # for k in range(1, 3): # ns = ns + [int(np.sum(matlist[k], 1)[0])] # W = makeW(ns) # Assumption: matlist[1] and matlist[2] are marginal queries numInMarg1 = np.sum(matlist[1], 1)[0] numInMarg2 = np.sum(matlist[2], 1)[0] matlistcopy = matlist[:] # to avoid overwriting matlist zlistcopy = zlist[:] epslistcopy = epslist[:] if numInMarg1 > numInMarg2: matlistcopy[1:3] = matlist[2:0:-1] zlistcopy[1:3] = zlist[2:0:-1] epslistcopy[1:3] = epslist[2:0:-1] ns = [matlistcopy[1].shape[0], matlistcopy[2].shape[0]] W = np.vstack(matlistcopy) oracle = Oracle(zlistcopy, y, 1. / 4, d, 4., matlistcopy) A, Y, inequalities, M = SolRyanFindInputs(ns, epslistcopy[0], oracle, W, True, sigLevel=sig_level) queries = [(A, Y), (M, np.zeros(M.shape[0]))] return fitter.fit(queries, inequalities=inequalities, bound=(0., None))
def ols(matlist, zlist, epslist, *, equalities=None, inequalities=None): queries = list(zip(matlist, zlist, [e**2 for e in epslist])) return fitter.fit(queries, equalities=equalities, inequalities=inequalities)
################################################################################### # data processing data_before_fit = [] if mode == 0: data_before_fit = by_brightness.get_brightness_data(cap_frames[30:330]) elif mode == 1: data_before_fit = by_red.get_red_data(cap_frames[30:330]) elif mode == 2: data_before_fit = by_hsv.get_hsv_data(cap_frames[30:330]) ################################################################################### # MedianAverageFilter # data_hsv_filter = filter.median_average(data_hsv, 3) # print(data_hsv_filter) data_after_fit = np.array(fitter.fit(data_before_fit)) data_fixed = data_before_fit - data_after_fit ################################################################################### # count peak data_heart_frame = peak_counter.count_peak(data_fixed) # calculate hrv # hr = heart_rate.get_heart_rate(data_heart_frame, 30) hrv_sdnn = heart_rate.get_heart_rate_variability(data_heart_frame, fps) # print('Minimum heart rate: ' + str(hrv_sdnn[0])) # print('Maximum heart rate: ' + str(hrv_sdnn[1])) # print('Average heart rate: ' + str(hrv_sdnn[2])) # print('Heart rate variability: ' + str(hrv_sdnn[3])) show = '+------------------------------------------------------+\n' \ '|Average heart rate: %3d |\n' \