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' \