def get_corr_map_fast(coo1, coo2, skypos, skyrange, sec, bound, bandwidth):
imsz = imagetools.deg2pix(skypos, skyrange, 0.0001)
count = np.zeros(imsz)
print(imsz)
co_rel = np.array([[0,0]])
len1 = coo1.shape[0]
len2 = coo2.shape[0]
print(len1,len2)
wcs = imagetools.define_wcs(skypos,skyrange,width=False,height=False,verbose=0,pixsz=0.0001)
#with open('../data/try2_%d.csv'%sec, 'wb') as csvfile:
#writer = csv.writer(csvfile)
if len2>len1:
for i in range(len1):
#print(i)
tmp_co = coo2-coo1[i,:]
tmp_co = tmp_co[np.absolute(tmp_co[:,0])<=bound,:]
tmp_co = tmp_co[np.absolute(tmp_co[:,1])<=bound,:]
co_rel = np.concatenate((co_rel, tmp_co), axis = 0)
else:
for i in range(len2):
#print(i)
tmp_co = coo2[i,:]-coo1
tmp_co = tmp_co[np.absolute(tmp_co[:,0])<=bound,:]
tmp_co = tmp_co[np.absolute(tmp_co[:,1])<=bound,:]
co_rel = np.concatenate((co_rel, tmp_co), axis = 0)
print co_rel.shape
if co_rel.shape[0]>50:
centroid = ck.find_centroid(co_rel[1:], bandwidth, 11, bound)
else:
return count, np.array([0.0, 0.0])
return count, centroid
def test_matrix_assemble(dim):
eps = 1000*DOLFIN_EPS
(u, uu), (v, vv), (U, UU), dPP, bc = _create_dp_problem(dim)
# Scalar assemble
mat = assemble(u*v*U*dPP)
# Create a numpy matrix based on the local size of the vector
# and populate it with values from local vector
loc_range = u.vector().local_range()
vec_mat = np.zeros_like(mat.array())
vec_mat[range(loc_range[1] - loc_range[0]),
range(loc_range[0], loc_range[1])] = u.vector().get_local()
assert np.sum(np.absolute(mat.array() - vec_mat)) < eps
# Vector assemble
mat = assemble((uu[0]*vv[0]*UU[0] + uu[1]*vv[1]*UU[1])*dPP)
# Create a numpy matrix based on the local size of the vector
# and populate it with values from local vector
loc_range = uu.vector().local_range()
vec_mat = np.zeros_like(mat.array())
vec_mat[range(loc_range[1] - loc_range[0]),
range(loc_range[0], loc_range[1])] = uu.vector().get_local()
assert np.sum(np.absolute(mat.array() - vec_mat)) < eps
def aggregate(self, gs):
"""Aggregate Capital, Labor in Efficiency unit and Bequest over all cohorts"""
W, T, TS = self.W, self.T, self.TS
"""Aggregate all cohorts' capital and labor supply at each year"""
K1, L1 = array([[0 for t in range(TS)] for i in range(2)], dtype=float)
for t in range(TS):
if t <= TS-T-1:
K1[t] = sum([gs[t+y].apath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
L1[t] = sum([gs[t+y].epath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
self.Beq[t] = sum([gs[t+y].apath[-(y+1)]*self.pop[t,-(y+1)]
/self.sp[t,-(y+1)]*(1-self.sp[t,-(y+1)]) for y in range(T)])
self.C[t] = sum([gs[t+y].cpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
else:
K1[t] = sum([gs[-1].apath[-(y+1)]*self.pop[t][-(y+1)] for y in range(T)])
L1[t] = sum([gs[-1].epath[-(y+1)]*self.pop[t][-(y+1)] for y in range(T)])
self.Beq[t] = sum([gs[-1].apath[-(y+1)]*self.pop[t,-(y+1)]
/self.sp[t,-(y+1)]*(1-self.sp[t,-(y+1)]) for y in range(T)])
self.C[t] = sum([gs[-1].cpath[-(y+1)]*self.pop[t][-(y+1)] for y in range(T)])
self.Converged = (max(absolute(K1-self.K)) < self.tol*max(absolute(self.K)))
""" Update the economy's aggregate K and N with weight phi on the old """
self.K = self.phi*self.K + (1-self.phi)*K1
self.L = self.phi*self.L + (1-self.phi)*L1
self.k = self.K/self.L
# print "K=%2.2f," %(self.K[0]),"L=%2.2f," %(self.L[0]),"K/L=%2.2f" %(self.k[0])
for i in range(self.TS/self.T):
print "K=%2.2f," %(self.K[i*self.T]),"L=%2.2f," %(self.L[i*self.T]),"K/L=%2.2f" %(self.k[i*self.T])
def paddingAnswers(answerSheet1, blankSheet1):
numRowsA, numColsA, numBandsA, dataTypeA = ipcv.dimensions(answerSheet1)
numRowsB, numColsB, numBandsB, dataTypeB = ipcv.dimensions(blankSheet1)
print numRowsB, numColsB
if numBandsA == 3:
answerSheet = cv2.cvtColor(answerSheet1, cv.CV_BGR2GRAY)
elif numBandsA == 1:
answerSheet = answerSheet1
if numBandsB == 3:
blankSheet = cv2.cvtColor(blankSheet1, cv.CV_BGR2GRAY)
elif numBandsB == 1:
blankSheet = blankSheet1
pad = numpy.absolute(numRowsA - numColsA)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsA-numColsA) % 2 != 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
answerSheet = numpy.pad(answerSheet, ((0,0),(pad,pad)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
pad1 = numpy.absolute(numRowsB - numColsB)/2.0
maxCount = numpy.max(blankSheet)
if (numRowsB-numColsB) % 2 != 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1+1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
elif (numRowsA-numColsA) % 2 == 0:
blankSheet = numpy.pad(blankSheet, ((0,0),(pad1,pad1)), 'constant', constant_values=((maxCount, maxCount),(maxCount,maxCount)))
return answerSheet, blankSheet
def getEnergy(self, normalized=True, mask=None):
"""
Returns the current energy.
Parameters:
normalized: Flag to return the normalized energy (that is, divided
by the total density)
"""
if self.gpu:
psi = self.psi.get()
V = self.Vdt.get() / self.dt
else:
psi = self.psi
V = self.Vdt.get() / self.dt
density = np.absolute(psi) ** 2
gradx = np.gradient(psi)[0]
normFactor = density.sum() if normalized else 1.0
return (
np.ma.array(
-(
0.25 * np.gradient(np.gradient(density)[0])[0]
- 0.5 * np.absolute(gradx) ** 2
- (self.g_C * density + V) * density
),
mask=mask,
).sum()
/ normFactor
)
def errore_trasporto_upwind(n_iter, M, N, xmin, xmax, tinz, tfin, vel, ic):
"""Analisi errore trasporto upwind"""
dx = zeros(n_iter)
e1 = zeros(n_iter)
e2 = zeros(n_iter)
esup = zeros(n_iter)
uexac = zeros([M + 1])
dx[0] = (xmax - xmin) / M
(u, x, t) = trasporto_upwind(M, N, xmin, xmax, tinz, tfin, vel, ic)
uexac[0:M + 1] = ic(vel(x, t[-1]))
e1[0] = dx[0] * sum(absolute(u[:, -1] - uexac))
e2[0] = sqrt(dx[0] * sum(absolute(u[:, -1] - uexac) ** 2))
esup[0] = max(abs(u[:, -1] - uexac))
for i in range(1, n_iter):
print i
M *= 2
dx[i] = (xmax - xmin) / M
(u, x, t) = trasporto_upwind(M, N, xmin, xmax, tinz, tfin, vel, ic)
uexac = zeros([M + 1])
uexac[0:M + 1] = ic(vel(x, t[-1]))
e1[i] = dx[i] * sum(absolute(u[:, -1] - uexac))
e2[i] = sqrt(dx[i] * sum(absolute(u[:, -1] - uexac) ** 2))
esup[i] = max(abs(u[:, -1] - uexac))
return e1, e2, esup
def plotall(self):
real = self.z_data_raw.real
imag = self.z_data_raw.imag
real2 = self.z_data_sim.real
imag2 = self.z_data_sim.imag
fig = plt.figure(figsize=(15,5))
fig.canvas.set_window_title("Resonator fit")
plt.subplot(131)
plt.plot(real,imag,label='rawdata')
plt.plot(real2,imag2,label='fit')
plt.xlabel('Re(S21)')
plt.ylabel('Im(S21)')
plt.legend()
plt.subplot(132)
plt.plot(self.f_data*1e-9,np.absolute(self.z_data_raw),label='rawdata')
plt.plot(self.f_data*1e-9,np.absolute(self.z_data_sim),label='fit')
plt.xlabel('f (GHz)')
plt.ylabel('Amplitude')
plt.legend()
plt.subplot(133)
plt.plot(self.f_data*1e-9,np.unwrap(np.angle(self.z_data_raw)),label='rawdata')
plt.plot(self.f_data*1e-9,np.unwrap(np.angle(self.z_data_sim)),label='fit')
plt.xlabel('f (GHz)')
plt.ylabel('Phase')
plt.legend()
# plt.gcf().set_size_inches(15,5)
plt.tight_layout()
plt.show()
def aggregate(self, gs):
"""Aggregate Capital, Labor in Efficiency unit and Bequest over all cohorts"""
W, T, TS = self.W, self.T, self.TS
"""Aggregate all cohorts' capital and labor supply at each year"""
K1, L1, H1, R1 = array([[0 for t in range(TS)] for i in range(4)], dtype=float)
for t in range(TS):
if t <= TS-T-1:
K1[t] = sum([gs[t+y].apath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
L1[t] = sum([gs[t+y].epath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
H1[t] = sum([gs[t+y].hpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
R1[t] = sum([gs[t+y].rpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
self.Beq[t] = sum([gs[t+y].apath[-(y+1)]*self.pop[t,-(y+1)]
/self.sp[t,-(y+1)]*(1-self.sp[t,-(y+1)]) for y in range(T)])
self.C[t] = sum([gs[t+y].cpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
else:
K1[t] = sum([gs[-1].apath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
L1[t] = sum([gs[-1].epath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
H1[t] = sum([gs[-1].hpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
R1[t] = sum([gs[-1].rpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
self.Beq[t] = sum([gs[-1].apath[-(y+1)]*self.pop[t,-(y+1)]
/self.sp[t,-(y+1)]*(1-self.sp[t,-(y+1)]) for y in range(T)])
self.C[t] = sum([gs[-1].cpath[-(y+1)]*self.pop[t,-(y+1)] for y in range(T)])
self.Converged = (max(absolute(K1-self.K)) < self.tol*max(absolute(self.K)))
""" Update the economy's aggregate K and N with weight phi on the old """
self.K = self.phi*self.K + (1-self.phi)*K1
self.L = self.phi*self.L + (1-self.phi)*L1
self.k = self.K/self.L
self.Hd = H1
self.Rd = R1
self.Hd_Hs = self.Hd - self.Hs
def add_data(N):
if N<=37.0:
Ns=N
else:
Ns=37.0
X=Ns*pi*(f-f0)/f0
A=sin(X)/sin(X/Ns)
#ans=recur_exp(N, Np=37)
#A=sum([el[0]*exp(1j*2*pi*f/f0*el[1])/1.0 for el in ans])
#A=sum([1.0*exp(1j*2*pi*f/f0*el[1])/1.0 for el in ans])
#A=comb_A(N)
Asq=absolute(A)**2
#return Asq
Ga0=2*mu**2*Y0*Ns**2
Ga=Ga0*Asq/Ns**2
Ba=Ga0*(sin(2*X)-2*X)/(2*X**2)
w=2*pi*f
S13=1j*sqrt(2*Ga*GL)/(Ga+1j*Ba+1j*w*C+GL)
#
# if N>5:
# Ns=N-5
# else:
# Ns=1
# X=Ns*pi*(f-f0)/f0
# A=1*sin(X)/sin(X/Ns)
# Asq=A**2
# Ga0=2*mu**2*Y0*(Ns)**2
# Ga=Ga0*Asq/Ns**2
# Ba=Ga0*(sin(2*X)-2*X)/(2*X**2)
# w=2*pi*f
# S31=1j*sqrt(2*Ga*GL)/(Ga+1j*Ba+1j*w*C+GL)
#
return absolute(S13**2)
def mask_bad(m, badval = UNSEEN, rtol = 1.e-5, atol = 1.e-8):
"""Return a boolean array with True where m is close to badval
and False elsewhere
[absolute(m - badval) <= atol + rtol * absolute(badval)]"""
atol = npy.absolute(atol)
rtol = npy.absolute(rtol)
return npy.absolute(m - badval) <= atol + rtol * npy.absolute(badval)
def mask_good(m, badval = UNSEEN, rtol = 1.e-5, atol = 1.e-8):
"""Return a mask with False where m is close to badval
and True elsewhere
[absolute(m - badval) > atol + rtol * absolute(badval)]"""
atol = npy.absolute(atol)
rtol = npy.absolute(rtol)
return npy.absolute(m - badval) > atol + rtol * npy.absolute(badval)
def plotCoeff(X, y, obj, featureNames, whichReg):
""" Plot Regression's Coeff
"""
clf = classifiers[whichReg]
clf,_,_ = fitAlgo(clf, X,y, opt= True, param_dict = param_dist_dict[whichReg])
if whichReg == "LogisticRegression":
coeff = np.absolute(clf.coef_[0])
else:
coeff = np.absolute(clf.coef_)
print coeff
indices = np.argsort(coeff)[::-1]
print indices
print featureNames
featureList = []
# num_features = len(featureNames)
print("Feature ranking:")
for f in range(num_features):
featureList.append(featureNames[indices[f]])
print("%d. feature %s (%.2f)" % (f, featureNames[indices[f]], coeff[indices[f]]))
fig = pl.figure(figsize=(8,6),dpi=150)
pl.title("Feature importances",fontsize=30)
# pl.bar(range(num_features), coeff[indices],
# yerr = std_importance[indices], color=paired[0], align="center",
# edgecolor=paired[0],ecolor=paired[1])
pl.bar(range(num_features), coeff[indices], color=paired[0], align="center",
edgecolor=paired[0],ecolor=paired[1])
pl.xticks(range(num_features), featureList, size=15,rotation=90)
pl.ylabel("Importance",size=30)
pl.yticks(size=20)
pl.xlim([-1, num_features])
# fix_axes()
pl.tight_layout()
save_path = 'plots/'+obj+'/'+whichReg+'_feature_importances.pdf'
fig.savefig(save_path)
def calculateMie(data):
# Extract data
(p, w, n_p, n_medium, th, n_theta, x_rv) = data
# Size parameter
# x - size parameter = k*radius = 2pi/lambda * radius
# (lambda is the wavelength in the medium around the scatterers)
x = np.pi * p / (w / n_medium)
# Mie parameters
(S1, S2, Qext, Qsca, Qback, gsca) = bhmie(x, n_p / n_medium, n_theta)
# Phase function
P = (np.absolute(S1) ** 2.0 + np.absolute(S2) ** 2.0) / \
(Qsca * x ** 2.0)
# Cumulative distribution
cP = st.cumulativeDistributionTheta(P, th)
# Normalize
cP /= cP[-1]
# Inverse cumulative distribution for random variable picking
cPinv = st.invertNiceFunction(np.degrees(th), cP, x_rv)
pD = {}
pD['particleDiameter'] = p
pD['sizeParameter'] = x
pD['wavelength'] = w
pD['crossSections'] = Qext * np.pi * (p / 2.0) ** 2.0
pD['inverseCDF'] = cPinv
pD['phaseFunction'] = P
pD['cumulativePhaseFunction'] = cP
# Return generated data
return pD
def callback(data):
# trouble shoot - print data from subscriber
#rospy.loginfo(rospy.get_caller_id() + "leftx: %s, rightx: %s", data.leftx, data.rightx)
# unpack values
global m1val
global m2val
global xl
global xr
xlnew = float(data.leftx);
xrnew = float(data.rightx);
if(numpy.absolute(xlnew-xl) < 0.02):
xl = xlnew;
#else:
#print('invalid x1, not updated')
if(numpy.absolute(xrnew-xr) < 0.02):
xr = xrnew;
#else:
#print('invalid x2, not updated')
xlcm = xl * 100;
xrcm = xr * 100;
#print 'leftx: {0:.3f} cm, rightx: {1:.3f} cm.'.format(xlcm, xrcm)
# read currents
m1cur, m2cur = readcurrents();
def mask_good(m, badval=UNSEEN, rtol=1.0e-5, atol=1.0e-8):
"""Returns a bool array with ``False`` where m is close to badval.
Parameters
----------
m : a map (may be a sequence of maps)
badval : float, optional
The value of the pixel considered as bad (:const:`UNSEEN` by default)
rtol : float, optional
The relative tolerance
atol : float, optional
The absolute tolerance
Returns
-------
a bool array with the same shape as the input map, ``False`` where input map is
close to badval, and ``True`` elsewhere.
See Also
--------
mask_bad, ma
Examples
--------
>>> import healpy as hp
>>> m = np.arange(12.)
>>> m[3] = hp.UNSEEN
>>> hp.mask_good(m)
array([ True, True, True, False, True, True, True, True, True,
True, True, True], dtype=bool)
"""
m = np.asarray(m)
atol = np.absolute(atol)
rtol = np.absolute(rtol)
return np.absolute(m - badval) > atol + rtol * np.absolute(badval)
def get_peaks_cf(data, win_size):
"""
data: audio as numpy array to be analyzed
win_size: value in samples to create the blocks for analysis
Used in calc_crest_factor, this function returns an array of peak levels
for each window.
return: array of peak audio levels
"""
if len(data) == 2:
# Seperate left and right channels
data_l = data[0,:]
data_r = data[1,:]
# Buffer up the data
data_matrix_l = librosa.util.frame(data_l, win_size, win_size)
data_matrix_r = librosa.util.frame(data_r, win_size, win_size)
# Get peaks for left and right channels
peaks_l = np.amax(np.absolute(data_matrix_l), axis=0)
peaks_r = np.amax(np.absolute(data_matrix_r), axis=0)
return np.maximum(peaks_l, peaks_r)
else:
data_matrix = librosa.util.frame(data, win_size, win_size)
return np.amax(np.absolute(data_matrix), axis=0)
def niceformat(x, l, s):
"""Get a nice formatted string of a number.
Parameters:
x: scalar
l: boolean
latex expression if True else ordinary
s: boolean
use '$' if True else don't
Returns: expr
expr: string
string representing the number
no measure unit
"""
if l:
pref = PREFIXES.copy()
if s:
pref[-6] = r'$\mu$'
else:
pref[-6] = r'\mu'
else:
pref = PREFIXES
xexp = 0
while np.absolute(x) < 1 and xexp >= min(PREFIXES.keys()):
xexp -= 3
x *= 1000.
while np.absolute(x) >= 1e3 and xexp <= max(PREFIXES.keys()):
xexp += 3
x /= 1000.
s = '%.4g'%x + ' ' + pref[xexp]
return s
def calc_num_walls(side_length, room_positions, ap_positions):
"""
Calculate the number of walls between each room to each AP.
This is used to calculate the wall losses as well as the indoor
pathloss.
Parameters
----------
side_length : float
The side length of the square room.
room_positions : 2D complex numpy array
The positions of all rooms in the grid.
ap_positions : 1D complex numpy array
The positions of access points in the grid.
Returns
-------
num_walls : 2D numpy array of ints
The number of walls from each room to access point.
"""
all_positions_diffs = room_positions.reshape(-1, 1) - 1.0001 * ap_positions.reshape(1, -1)
num_walls = np.round(
np.absolute(np.real(all_positions_diffs / side_length))
+ np.absolute(np.imag(all_positions_diffs / side_length))
).astype(int)
return num_walls
def motion_update(self, X_t, O1, O2):
O_d = O2 - O1
t = np.sqrt(np.sum(np.power(O_d[0:2],2)))
r1 = np.arctan2(O_d[1], O_d[0]) - O1[2]
r2 = -r1 + O_d[2]
sig_t = np.finfo(float).eps + self.a[2] * np.absolute(t)
sig_r1 = np.finfo(float).eps + self.a[0] * np.absolute(r1)
sig_r2 = np.finfo(float).eps + self.a[1] * np.absolute(r2)
# sig_t = np.finfo(float).eps + np.sqrt(self.a[2] * np.absolute(t) + self.a[3] * np.absolute(r1+r2))
# sig_r1 = np.finfo(float).eps + np.sqrt(self.a[0] * np.absolute(r1) + self.a[1] * np.absolute(t))
# sig_r2 = np.finfo(float).eps + np.sqrt(self.a[0] * np.absolute(r2) + self.a[1] * np.absolute(t))
# print('heeee')
# print(sig_r1)
# print(sig_r2)
h_t = np.reshape(t + np.random.normal(0,sig_t,len(X_t)), (len(X_t),1))
h_r1 = r1 + np.random.normal(0,sig_r1,len(X_t))
h_r2 = r2 + np.random.normal(0,sig_r2,len(X_t))
th = np.reshape(X_t[:,2] + h_r1, (len(X_t),1))
pos = X_t[:,:2] + np.concatenate((np.cos(th), np.sin(th)), axis=1) * h_t
ang = np.reshape(X_t[:,2]+h_r1+h_r2, (len(X_t),1))
ang = (ang + (- 2*np.pi)*(ang > np.pi) + (2*np.pi)*(ang < -np.pi))
X_upd = np.concatenate((pos,ang), axis=1)
map_c = np.ceil(pos/10).astype(int)
count = 0;
for i in range(len(X_upd)):
if(self.unocc_dict.has_key(tuple(map_c[i]))):
X_upd[count] = X_upd[i]
count = count+1
# print(count)
return X_upd[:count,:]
def crunchy3(offset, eta, sec, sigma=None):
powers = []
powers_norm = []
y_axis = sec.get_y_axis()
x_axis = sec.get_x_axis()
px_y = np.absolute(y_axis[1] - y_axis[0])
px_x = np.absolute(x_axis[1] - x_axis[0])
if sigma is None:
sigma = [px_y, px_x]
if sigma[0] < px_y:
sigma = [px_y, sigma[1]]
if sigma[1] < px_x:
sigma = [sigma[0], px_x]
for yi in range(len(y_axis)):
y = y_axis[yi]
for xi in range(len(x_axis)):
x = x_axis[xi]
y_eff = y + eta * offset ** 2
x_eff = x - offset
this_weight = weight_function3(eta, y, x, y_eff, x_eff, sigma)
if this_weight is None:
powers.append(None)
powers_norm.append(None)
else:
variance = 1 / this_weight
powers.append(sec.get([yi, xi]) / variance)
powers_norm.append(1 / variance)
p = np.nansum(list(filter(None, powers)))
pn = np.nansum(list(filter(None, powers_norm)))
return offset, p / pn
def crunchy(eta, sec, hand=None, sigma=None):
powers = []
powers_norm = []
y_axis = sec.get_y_axis()
x_axis = sec.get_x_axis()
if sigma is None:
sigma = [np.absolute(y_axis[1] - y_axis[0]),
np.absolute(x_axis[1] - x_axis[0])]
for yi in range(len(y_axis)):
y = y_axis[yi]
for xi in range(len(x_axis)):
x = x_axis[xi]
this_weight = weight_function(eta, x, y, sigma)
if this_weight is None:
powers.append(None)
powers_norm.append(None)
else:
variance = 1 / this_weight
powers.append(sec.get([yi, xi]) / variance)
powers_norm.append(1 / variance)
p = np.nansum(list(filter(None, powers)))
pn = np.nansum(list(filter(None, powers_norm)))
# print("eta: " + str(eta))
# print(p)
# print(pn)
# print("p/pn: " + str(p/pn))
return eta, p / pn
def det_trace_iter(A, v, E):
"""
:param A: input matrix
:param v: vector used for power method
:param E: tolerance parameter
:return: (determinant, trace, N) ->determinant, trace, number of iterations
"""
N = 0
err = 0
lamda = 0
while np.absolute(err) >= np.absolute(lamda * E) and N <= 100:
N += 1
temp = matrix_multiply(A, v)
newlamda = matrix_multiply(np.transpose(v), temp)[0, 0]
newlamda = newlamda / matrix_multiply(np.transpose(v), v)[0, 0]
# can we use magnitude method???
err = np.absolute(newlamda - lamda)
v = temp
lamda = newlamda
# does multiple multiplication for power method!!!
if np.absolute(err) < np.absolute(lamda * E):
return (determinant_for_2x2(A), trace(A), N)
else:
#print("Uhh, failed")
return None
def curvature_optimisation_func_lensmaker(curv_1 = 0.002, focal_length = 100.,
diameter = 5., thickness = 5., ref_index = 1.5):
"""
This function is used to minimise the RMS spread of a beam of given
diameter, propagated through a lens of given thickness, by changing
the curvatures of the two sides of the lens. It is meant to be used
in conjunction with an optimisation function.
This function is bounded by the lensmaker equation, so it only requires
one curvature as an argument and the other is calculated using the
given focal length, thickness, and refractive index.
"""
curv_2 = lensmaker_equation(curv_1, focal_length, thickness, ref_index)
if curv_2 == 0:
curv_2 -= 1e-13
if curv_1 == 0:
curv_1 += 1e-13
aperture_radius_1 = np.absolute(1/float(curv_1))
aperture_radius_1 -= 1e-6*aperture_radius_1
aperture_radius_2 = np.absolute(1/float(curv_2))
aperture_radius_2 -= 1e-6*aperture_radius_2
lens_front = opt.SphericalRefraction(focal_length, curv_1,
aperture_radius_1, 1., ref_index)
lens_back = opt.SphericalRefraction(focal_length + thickness,
curv_2, aperture_radius_2,
ref_index, 1.)
max_radius = diameter/2.
test_beam = rt.CollimatedBeam([0,0,0], [0,0,1], 6, max_radius, 2)
rms_spread = rms_xy_spread([lens_front, lens_back], focal_length, test_beam)
return np.log10(rms_spread)
def compareRecon(recon1, recon2):
''' compare two arrays and return 1 is they are the same within specified
precision and 0 if not.
function was made to accompany unit test code '''
## FIX: make precision a input parameter
prec = -11 # desired precision
if recon1.shape != recon2.shape:
print 'shape is different!'
print recon1.shape
print recon2.shape
return 0
for i in range(recon1.shape[0]):
for j in range(recon2.shape[1]):
if numpy.absolute(recon1[i,j].real - recon2[i,j].real) > math.pow(10,-11):
print "real: i=%d j=%d %.15f %.15f diff=%.15f" % (i, j, recon1[i,j].real, recon2[i,j].real, numpy.absolute(recon1[i,j].real-recon2[i,j].real))
return 0
## FIX: need a better way to test
# if we have many significant digits to the left of decimal we
# need to be less stringent about digits to the right.
# The code below works, but there must be a better way.
if isinstance(recon1, complex):
if int(math.log(numpy.abs(recon1[i,j].imag), 10)) > 1:
prec = prec + int(math.log(numpy.abs(recon1[i,j].imag), 10))
if prec > 0:
prec = -1
print prec
if numpy.absolute(recon1[i,j].imag - recon2[i,j].imag) > math.pow(10, prec):
print "imag: i=%d j=%d %.15f %.15f diff=%.15f" % (i, j, recon1[i,j].imag, recon2[i,j].imag, numpy.absolute(recon1[i,j].imag-recon2[i,j].imag))
return 0
return 1
def isEqual(left, right, eps=None, masked_equal=True):
''' This function checks if two numpy arrays or scalars are equal within machine precision, and returns a scalar logical. '''
diff_type = "Both arguments to function 'isEqual' must be of the same class!"
if isinstance(left,np.ndarray):
# ndarray
if not isinstance(right,np.ndarray): raise TypeError(diff_type)
if not left.dtype==right.dtype:
right = right.astype(left.dtype) # casting='same_kind' doesn't work...
if np.issubdtype(left.dtype, np.inexact): # also catch float32 etc
if eps is None: return ma.allclose(left, right, masked_equal=masked_equal)
else: return ma.allclose(left, right, masked_equal=masked_equal, atol=eps)
elif np.issubdtype(left.dtype, np.integer) or np.issubdtype(left.dtype, np.bool):
return np.all( left == right ) # need to use numpy's all()
elif isinstance(left,(float,np.inexact)):
# numbers
if not isinstance(right,(float,np.inexact)): raise TypeError(diff_type)
if eps is None: eps = 100.*floateps # default
if ( isinstance(right,float) or isinstance(right,float) ) or left.dtype.itemsize == right.dtype.itemsize:
return np.absolute(left-right) <= eps
else:
if left.dtype.itemsize < right.dtype.itemsize: right = left.dtype.type(right)
else: left = right.dtype.type(left)
return np.absolute(left-right) <= eps
elif isinstance(left,(int,bool,np.integer,np.bool)):
# logicals
if not isinstance(right,(int,bool,np.integer,np.bool)): raise TypeError(diff_type)
return left == right
else: raise TypeError(left)
def _exec_loop(self, a, bd_all, mask):
"""Solves the kriging system by looping over all specified points.
Less memory-intensive, but involves a Python-level loop."""
npt = bd_all.shape[0]
n = self.X_ADJUSTED.shape[0]
zvalues = np.zeros(npt)
sigmasq = np.zeros(npt)
a_inv = scipy.linalg.inv(a)
for j in np.nonzero(~mask)[0]: # Note that this is the same thing as range(npt) if mask is not defined,
bd = bd_all[j] # otherwise it takes the non-masked elements.
if np.any(np.absolute(bd) <= self.eps):
zero_value = True
zero_index = np.where(np.absolute(bd) <= self.eps)
else:
zero_index = None
zero_value = False
b = np.zeros((n+1, 1))
b[:n, 0] = - self.variogram_function(self.variogram_model_parameters, bd)
if zero_value:
b[zero_index[0], 0] = 0.0
b[n, 0] = 1.0
x = np.dot(a_inv, b)
zvalues[j] = np.sum(x[:n, 0] * self.Z)
sigmasq[j] = np.sum(x[:, 0] * -b[:, 0])
return zvalues, sigmasq
def _exec_loop_moving_window(self, a_all, bd_all, mask, bd_idx):
"""Solves the kriging system by looping over all specified points.
Less memory-intensive, but involves a Python-level loop."""
import scipy.linalg.lapack
npt = bd_all.shape[0]
n = bd_idx.shape[1]
zvalues = np.zeros(npt)
sigmasq = np.zeros(npt)
for i in np.nonzero(~mask)[0]: # Note that this is the same thing as range(npt) if mask is not defined,
b_selector = bd_idx[i] # otherwise it takes the non-masked elements.
bd = bd_all[i]
a_selector = np.concatenate((b_selector, np.array([a_all.shape[0] - 1])))
a = a_all[a_selector[:, None], a_selector]
if np.any(np.absolute(bd) <= self.eps):
zero_value = True
zero_index = np.where(np.absolute(bd) <= self.eps)
else:
zero_index = None
zero_value = False
b = np.zeros((n+1, 1))
b[:n, 0] = - self.variogram_function(self.variogram_model_parameters, bd)
if zero_value:
b[zero_index[0], 0] = 0.0
b[n, 0] = 1.0
x = scipy.linalg.solve(a, b)
zvalues[i] = x[:n, 0].dot(self.Z[b_selector])
sigmasq[i] = - x[:, 0].dot(b[:, 0])
return zvalues, sigmasq
def estimate(data):
length=len(data)
wave=thinkdsp.Wave(ys=data,framerate=Fs)
spectrum=wave.make_spectrum()
spectrum_heart=wave.make_spectrum()
spectrum_resp=wave.make_spectrum()
fft_mag=list(np.absolute(spectrum.hs))
fft_length= len(fft_mag)
spectrum_heart.high_pass(cutoff=0.8,factor=0.001)
spectrum_heart.low_pass(cutoff=2,factor=0.001)
fft_heart=list(np.absolute(spectrum_heart.hs))
max_fft_heart=max(fft_heart)
heart_sample=fft_heart.index(max_fft_heart)
hr=heart_sample*Fs/length*60
spectrum_resp.high_pass(cutoff=0.15,factor=0)
spectrum_resp.low_pass(cutoff=0.4,factor=0)
fft_resp=list(np.absolute(spectrum_resp.hs))
max_fft_resp=max(fft_resp)
resp_sample=fft_resp.index(max_fft_resp)
rr=resp_sample*Fs/length*60
print "Heart Rate:", hr, "BPM"
if hr<10:
print "Respiration Rate: 0 RPM"
else:
print "Respiration Rate:", rr, "RPM"
return
def _exec_vector(self, a, bd, mask):
"""Solves the kriging system as a vectorized operation. This method
can take a lot of memory for large grids and/or large datasets."""
npt = bd.shape[0]
n = self.X_ADJUSTED.shape[0]
zero_index = None
zero_value = False
a_inv = scipy.linalg.inv(a)
if np.any(np.absolute(bd) <= self.eps):
zero_value = True
zero_index = np.where(np.absolute(bd) <= self.eps)
b = np.zeros((npt, n+1, 1))
b[:, :n, 0] = - self.variogram_function(self.variogram_model_parameters, bd)
if zero_value:
b[zero_index[0], zero_index[1], 0] = 0.0
b[:, n, 0] = 1.0
if (~mask).any():
mask_b = np.repeat(mask[:, np.newaxis, np.newaxis], n+1, axis=1)
b = np.ma.array(b, mask=mask_b)
x = np.dot(a_inv, b.reshape((npt, n+1)).T).reshape((1, n+1, npt)).T
zvalues = np.sum(x[:, :n, 0] * self.Z, axis=1)
sigmasq = np.sum(x[:, :, 0] * -b[:, :, 0], axis=1)
return zvalues, sigmasq
def crunchy2(pt_and_sigma, sec, hand=None):
pt, sigma = pt_and_sigma
py, px = pt
powers = []
powers_norm = []
y_axis = sec.get_y_axis()
x_axis = sec.get_x_axis()
px_y = np.absolute(y_axis[1] - y_axis[0])
px_x = np.absolute(x_axis[1] - x_axis[0])
if sigma == None:
sigma = [px_y, px_x]
if sigma[0] < px_y:
sigma = [px_y, sigma[1]]
if sigma[1] < px_x:
sigma = [sigma[0], px_x]
for yi in range(len(y_axis)):
y = y_axis[yi]
for xi in range(len(x_axis)):
x = x_axis[xi]
this_weight = weight_function2(y, x, py, px, sigma)
if this_weight is None:
powers.append(None)
powers_norm.append(None)
else:
variance = 1 / this_weight
powers.append(sec.get([yi, xi]) / variance)
powers_norm.append(1 / variance)
p = np.nansum(list(filter(None, powers)))
pn = np.nansum(list(filter(None, powers_norm)))
return pt, p / pn
def spectrum_magnitude(frames, NFFT):
# fft变换
complex_spectrum = numpy.fft.rfft(frames, NFFT)
return numpy.absolute(complex_spectrum)
def validate(ensemble,
test,
testout,
test_gridday,
frames_grid,
margin,
qt,
spatial_channel=[],
forecast_channel=[],
calculate_channel={}):
errorsum = 0
averagetotalerror = 0
cnt = 1
channels = test.shape[-1]
predicttotal = pd.DataFrame()
pix = np.int(np.sqrt(max(frames_grid['pixno'])))
gridpix = np.flip(
np.array(range(1,
max(frames_grid['pixno']) + 1)).reshape(pix, pix), 0)
gridpix = gridpix[margin:pix - margin, margin:pix - margin]
errorframe = pd.DataFrame()
minpop = min(frames_grid['norm_pop'])
span = test_gridday[0][1]
forecast_frames_grid = frames_grid[
frames_grid['day'] <= max(frames_grid['day']) - span]
forecast_frames_grid_array = []
colnames = frames_grid.columns
for k, (grid, span) in test_gridday.items():
######## for each test grid
grid_forecast_frames_grid = pickle.loads(
pickle.dumps(
forecast_frames_grid[forecast_frames_grid.grid == grid], -1))
_forecast_frames_grid = pickle.loads(
pickle.dumps(
grid_forecast_frames_grid[
grid_forecast_frames_grid['day'] == max(
grid_forecast_frames_grid['day'])], -1))
track = test[k]
totpop = track[0, ::, ::, 1]
pix = totpop.shape[0]
print(grid)
popexists = pickle.loads(pickle.dumps(totpop[::, ::], -1))
popexists[popexists > 0] = 1
popexists_size = len(popexists[popexists > 0].flatten())
out = testout[k]
######## for each prediction day
for i in range(span):
new_pos = ensemble.predict(track[np.newaxis, ::, ::, ::, ::])
#new_pos = ensemble_predict(ensemble,track[np.newaxis, ::, ::, ::, ::])
new = new_pos[::, ::, ::, ::]
new = np.multiply(new[0, ::, ::, 0], popexists)[np.newaxis, ::, ::,
np.newaxis]
new[new < 0] = 0
new[new > 1] = 1
gamma = forecast_gamma(grid_forecast_frames_grid, grid, span)
_forecast_frames_grid = calculate_future_SIR(
_forecast_frames_grid,
grid,
forecastbeta=new[0, ::, ::, 0],
forecastgamma=gamma,
qt=qt)
if len(forecast_frames_grid_array) != 0:
forecast_frames_grid_array = np.concatenate(
(forecast_frames_grid_array, _forecast_frames_grid.values),
axis=0)
else:
forecast_frames_grid_array = _forecast_frames_grid.values
#print("forecast done")
########### append channels
newtrack = new
for channel in range(1, channels):
if channel in spatial_channel:
channel_data = track[i, ::, ::, channel]
newtrack = np.concatenate(
(newtrack, channel_data[np.newaxis, ::, ::,
np.newaxis]),
axis=3)
elif channel in forecast_channel:
channel_data = out[i, ::, ::, channel]
newtrack = np.concatenate(
(newtrack, channel_data[np.newaxis, ::, ::,
np.newaxis]),
axis=3)
elif channel in calculate_channel:
channel2 = np.flip(
np.array(_forecast_frames_grid[
calculate_channel[channel]]).reshape(pix, pix), 0)
newtrack = np.concatenate(
(newtrack, channel2[np.newaxis, ::, ::, np.newaxis]),
axis=3)
#print(channels,spatialorforecast_channel,newtrack.shape,track.shape)
track = np.concatenate((track, newtrack), axis=0)
predictframe = np.squeeze(new, 0)[::, ::, 0][margin:pix - margin,
margin:pix - margin]
actualframe = out[i, ::, ::, 0][margin:pix - margin,
margin:pix - margin]
notzeroframe = pickle.loads(pickle.dumps(actualframe, -1))
notzeroframe[notzeroframe == 0] = 1
_errorframe = pd.DataFrame({
'pixno':
gridpix[totpop[margin:pix - margin,
margin:pix - margin] > 0].flatten(),
'predict':
predictframe[totpop[margin:pix - margin,
margin:pix - margin] > 0].flatten(),
'actual':
actualframe[totpop[margin:pix - margin,
margin:pix - margin] > 0].flatten()
})
_errorframe['day'] = i
_errorframe['grid'] = grid
errorframe = errorframe.append(_errorframe)
error = np.sum(
np.absolute((predictframe - actualframe) /
notzeroframe)) / (popexists_size + 1)
averagetotalerror += np.sum(
np.absolute(
(predictframe - actualframe))) / (popexists_size + 1)
errorsum += error
cnt += 1
averageerror = errorsum / cnt
averagetotalerror /= cnt
forecast_frames_grid = pd.DataFrame(forecast_frames_grid_array)
forecast_frames_grid.columns = colnames
return (averageerror, averagetotalerror, forecast_frames_grid)
def run(self):
# Run the Q-learning algoritm.
discrepancy = []
self.time = _time.time()
# initial state choice
s = _np.random.randint(0, self.S)
for n in range(1, self.max_iter + 1):
# Reinitialisation of trajectories every 100 transitions
if (n % 100) == 0:
s = _np.random.randint(0, self.S)
# Action choice
pn = _np.random.random()
if pn < (1 - self.epsilon):
# optimal_action = self.Q[s, :].max()
a = self.Q[s, :].argmax()
else:
a = _np.random.randint(0, self.A)
self.epsilon *= self.decay
# Simulating next state s_new and reward associated to <s,s_new,a>
p_s_new = _np.random.random()
p = 0
s_new = -1
while (p < p_s_new) and (s_new < (self.S - 1)):
s_new = s_new + 1
p = p + self.P[a][s, s_new]
try:
r = self.R[a][s, s_new]
except IndexError:
try:
r = self.R[s, a]
except IndexError:
r = self.R[s]
# Updating the value of Q
# Decaying update coefficient (1/sqrt(n+2)) can be changed
delta = r + self.discount * self.Q[s_new, :].max() - self.Q[s, a]
dQ = self.alpha * delta
self.Q[s, a] = self.Q[s, a] + dQ
# current state is updated
s = s_new
# Computing and saving maximal values of the Q variation
discrepancy.append(_np.absolute(dQ))
# Computing means all over maximal Q variations values
if len(discrepancy) == 1000:
self.mean_discrepancy.append(_np.mean(discrepancy))
discrepancy = []
# compute the value function and the policy
self.V = self.Q.max(axis=1)
self.policy = self.Q.argmax(axis=1)
self._endRun()
(0, 255, 0), 2)
# print "eye " + str(ex) + " " + str(ey)
# roi_eye = roi_face[int(1.2*ey):int(0.8*(ey+eh)), int(1.2*ex):int(0.8*(ex+ew))]
roi_eye = roi_face[ey:ey + eh, ex:ex + ew]
center = 0
roi_eye = cv2.GaussianBlur(roi_eye, (3, 3), 0)
roi_eye = cv2.addWeighted(roi_eye, 1.5, roi_eye, -0.5, 0)
roi_eye_canny = cv2.Canny(roi_eye, 100, 200)
cv2.imwrite('./data/canny' + str(counter) + '.png', roi_eye_canny)
laplacian = cv2.Laplacian(roi_eye, cv2.CV_64F)
cv2.imwrite('./data/lapla' + str(counter) + '.png', laplacian)
# res = cv2.resize(roi_eye,(int(ew/2), int(eh/2)), interpolation = cv2.INTER_AREA)
roi_eyex = cv2.Sobel(roi_eye, cv2.CV_64F, 1, 0, ksize=3)
roi_eyey = cv2.Sobel(roi_eye, cv2.CV_64F, 0, 1, ksize=3)
roi_eyex = np.absolute(roi_eyex)
roi_eyey = np.absolute(roi_eyey)
roi_eyex = np.uint8(roi_eyex)
roi_eyey = np.uint8(roi_eyey)
# sobelx64f = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=5)
# abs_sobel64f = np.absolute(sobelx64f)
# sobel_8u = np.uint8(abs_sobel64f)
cv2.imwrite('./data/zsobely' + str(counter) + '.png', roi_eyey)
cv2.imwrite('./data/zsobelx' + str(counter) + '.png', roi_eyex)
ret, tmp = cv2.threshold(roi_eyex, 0, 255, cv2.THRESH_OTSU)
tmp = cv2.erode(tmp, kernel, iterations=1)
cv2.imwrite('./data/zsobelxt' + str(counter) + '.png', tmp)
mag = np.hypot(roi_eyex, roi_eyey) # magnitude
mag *= 255.0 / np.max(mag) # normalize (Q&D)
print 'ret is ', ret
while ret == False:
print ''
blankFrame = np.zeros(np.shape(frame), np.uint8)
emptyFrame = blankFrame
emptyFrame32 = np.float32(blankFrame)
cv2.namedWindow('frame')
cv2.setMouseCallback('frame', setEmpty)
while(True):
_, frame = cap.read()
frame32 = np.float32(frame)
diff32 = np.absolute(frame32 - emptyFrame32)
norm32 = np.sqrt(diff32[:,:,0]**2 + diff32[:,:,1]**2 + diff32[:,:,2]**2)/np.sqrt(255**2 + 255**2 + 255**2)
diff = np.uint8(norm32*255)
_, thresh = cv2.threshold(diff, 100, 255, 0)
kernel = np.ones((20,20), np.uint8)
blobby = cv2.dilate(thresh, kernel, iterations= 4)
# buffer
pastBuff = currBuff
currBuff = ( (currBuff << 1) | (np.any(blobby)) ) & buffMask
if currBuff == buffMask:
cv2.imshow('frame', blobby)
else:
cv2.imshow('frame', blankFrame)
def get_reward_ABS(state, terminated):
"Calculates the environments reward for the next state"
if terminated:
return -10
return np.absolute(0.5 - state[0])
def apply_algos(algorithms, X, Y, visualize_results=False, fig_suptitple=''):
"""Apply classification algorithm to X and Y
X is positive Y is negative class
Parameters
----------
\n `X` (np.array) The data of class 1
\n `Y` (np.array) The data of class 2
\n `visualize_results` (boolean) If you want to plot results
\n `plot_ROC` (boolean) If you want to plot ROC
Returns
---------
(dict) `{"SCORE", "F_Measure_+", "F_Measure_-", "TPR", "TNR", "EER", "AUC"}`
"""
split_perc = 0.8
# Split Class 1 to train and test
np.random.shuffle(X)
X_train = X[0:int(np.ceil(split_perc * len(X))), :]
X_test = X[int(np.ceil(split_perc * len(X))):, :]
# Split Class 2 to train and test
np.random.shuffle(Y)
Y_train = Y[0:int(np.ceil(split_perc * len(Y))), :]
Y_test = Y[int(np.ceil(split_perc * len(Y))):, :]
# Merge data, construct labels
merged_train = np.append(X_train, Y_train, axis=0)
labels_train_true = len(X_train) * [0] + len(Y_train) * [1]
merged_test = np.append(X_test, Y_test, axis=0)
labels_test_true = len(X_test) * [0] + len(Y_test) * [1]
# Dict all results
labels_test_pred = {}
model = {}
fpr_pts, tpr_pts = {}, {}
F_Measure_Positive, F_Measure_Negative, TPR, TNR, SCORE, EER, AUC = {}, {}, {}, {}, {}, {}, {}
# Apply algorithms
for algorithm in algorithms:
# Apply and fit model
if hasattr(globals()[algorithm](), 'kernel') and hasattr(globals()[algorithm](), 'gamma'):
model[algorithm] = globals()[algorithm](kernel='rbf', gamma='auto')
elif hasattr(globals()[algorithm](), 'n_neighbors'):
model[algorithm] = globals()[algorithm](n_neighbors=5)
else:
model[algorithm] = globals()[algorithm]()
model[algorithm].fit(merged_train, labels_train_true)
# Predict
labels_test_pred[algorithm] = model[algorithm].predict(merged_test)
# Calculate Metrics
F_Measure_Positive[algorithm] = f1_score(
labels_test_true, labels_test_pred[algorithm], pos_label=1)
F_Measure_Negative[algorithm] = f1_score(
labels_test_true, labels_test_pred[algorithm], pos_label=0)
TPR[algorithm] = recall_score(
labels_test_true, labels_test_pred[algorithm], pos_label=1)
TNR[algorithm] = recall_score(
labels_test_true, labels_test_pred[algorithm], pos_label=0)
SCORE[algorithm] = model[algorithm].score(
merged_test, labels_test_true)
if hasattr(model[algorithm], 'decision_function'):
scores = model[algorithm].decision_function(merged_test)
elif hasattr(model[algorithm], 'predict_proba'):
scores = model[algorithm].predict_proba(merged_test)[:, 1]
else:
exit('No decision_function or predict_proba for model')
fpr_pts[algorithm], tpr_pts[algorithm], _ = roc_curve(
labels_test_true, scores, pos_label=1)
fnr_pts = 1 - tpr_pts[algorithm]
EER[algorithm] = (fpr_pts[algorithm][np.nanargmin(np.absolute((fnr_pts - fpr_pts[algorithm])))] +
fnr_pts[np.nanargmin(np.absolute((fnr_pts - fpr_pts[algorithm])))]) / 2
AUC[algorithm] = roc_auc_score(labels_test_true, scores)
# Show results if needed
# One figure for classification results, one algo in each subplot
# One figure for ROC curves, one roc algo curve in each subplot
if visualize_results is True:
if len(algorithms) == 1:
pltdim1, pltdim2 = 1, 1
elif len(algorithms) == 2:
pltdim1, pltdim2 = 1, 2
else:
pltdim1, pltdim2 = np.ceil(np.sqrt(len(algorithms))), np.ceil(
np.sqrt(len(algorithms)))
_3d = True if X.shape[1] == 3 else False
# Init Figure for class results
fig = plot.figure()
fig.suptitle(fig_suptitple)
for i, algorithm in enumerate(algorithms):
# Add subplot
ax = fig.add_subplot(
pltdim1, pltdim2, i + 1, projection='3d') if _3d is True else fig.add_subplot(pltdim1, pltdim2, i + 1)
# Add the separating hyperplane
if _3d is True:
if algorithm == 'SVC':
add_3d_hyperplane(model[algorithm], ax, np.append(
np.append(X_train, Y_train, axis=0), merged_test, axis=0))
else:
add_2d_hyperplane(model[algorithm], np.append(
np.append(X_train, Y_train, axis=0), merged_test, axis=0))
# Scatter X Train and Y Train
ax_X_train = add_scatter(ax, X_train, color='red', marker='o')
ax_Y_train = add_scatter(ax, Y_train, color='blue', marker='o')
leg_tuple_ax = (ax_X_train, ax_Y_train)
leg_tuple_str = ('Negative Class Training Data (%d)' % (len(X_train)),
'Positive Class Training Data (%d)' % (len(Y_train)))
# Scatter TN (Xclass) and FP
labels_X_test_pred = labels_test_pred[algorithm][0:len(X_test)]
ax_TN, lenTN, ax_FP, lenFP = add_scatter(ax, X_test, labels=labels_X_test_pred, labels_paint={
"colors": ['red', 'red'], "markers": ['o', 'o']})
leg_tuple_ax += (ax_TN, ax_FP)
leg_tuple_str += ('True Negatives (%d/%d)' % (lenTN, lenTN + lenFP),
'False Positives (%d/%d)' % (lenFP, lenTN + lenFP))
# Scatter TP (Yclass) and FN
labels_Y_test_pred = labels_test_pred[algorithm][len(X_test):]
ax_FN, lenFN, ax_TP, lenTP = add_scatter(ax, Y_test, labels=labels_Y_test_pred, labels_paint={
"colors": ['blue', 'blue'], "markers": ['o', 'o']})
leg_tuple_ax += (ax_TP, ax_FN)
leg_tuple_str += ('True Positives (%d/%d)' % (lenTP, lenTP + lenFN),
'False Negatives (%d/%d)' % (lenFN, lenTP + lenFN))
# Set Title and Legend
if algorithm == 'SVC':
algorithm_name = 'SVM'
elif algorithm == 'KNeighborsClassifier':
algorithm_name = 'kNN'
ax.set_title('Classifier: ' + algorithm_name)
# ax.set_title('Classifier: ' + algorithm_name + '\nF-Measure_+ = %.2f, F-Measure_- = %.2f, TPR = %.2f, TNR = %.2f, EER = %.2f' %
# (F_Measure_Positive[algorithm], F_Measure_Negative[algorithm], TPR[algorithm], TNR[algorithm], EER[algorithm]))
ax.legend(leg_tuple_ax, leg_tuple_str, loc=0,
bbox_to_anchor=(0, 0, 1, 0.93))
# ax.legend(leg_tuple_ax, leg_tuple_str, loc='upper right')
# Init Figure for ROCs
fig = plot.figure()
fig.suptitle(fig_suptitple)
# Plot ROC Curve
for i, algorithm in enumerate(algorithms):
line = fig.add_subplot(pltdim1, pltdim2, i + 1)
line.plot(fpr_pts[algorithm], tpr_pts[algorithm])
line.plot([0, 1], [0, 1], 'k--')
if algorithm == 'SVC':
algorithm_name = 'SVM'
elif algorithm == 'KNeighborsClassifier':
algorithm_name = 'kNN'
line.set_title(algorithm_name + '\nROC Curve, AUC = %.2f' %
(AUC[algorithm]))
line.set_xlabel('FPR')
line.set_ylabel('TPR')
# Show dem figs
plot.show()
return {"SCORE": SCORE,
"F_Measure_+": F_Measure_Positive,
"F_Measure_-": F_Measure_Negative,
"TPR": TPR,
"TNR": TNR,
"EER": EER,
"AUC": AUC
}
def F_integral(twiss_filename, energy, alpha_snake, Anomalous_magnetic_moment,
delta_phi, delta_y):
nu_mass = TwissParameter_nu_Gamma(twiss_filename)
ParametersForSRF = ParameterForSRF(twiss_filename)
# Parameter_W_ForSRF(ParametersForSRF)
zeta = np.array([float(i) for i in ParametersForSRF[0]])
S = np.array([float(i) for i in ParametersForSRF[1]])
length = np.array([float(i) for i in ParametersForSRF[2]])
angle = np.array([float(i) for i in ParametersForSRF[3]])
beta_y = np.array([float(i) for i in ParametersForSRF[4]])
alpha_y = np.array([float(i) for i in ParametersForSRF[5]])
mu_y = np.array([float(i) for i in ParametersForSRF[6]])
mu_y_temp_num = 2.0 * math.pi
mu_y = array_times_number(mu_y_temp_num, mu_y)
K1_L = np.array([float(i) for i in ParametersForSRF[7]])
nu_y = float(nu_mass[0])
mass = float(nu_mass[1])
gamma = float(energy) / mass
alpha_snake = float(alpha_snake)
B_moment_anomaly = float(Anomalous_magnetic_moment)
delta_phi = float(delta_phi)
delta_y = float(delta_y)
exp_compx_nu1 = complex_exp(2.0 * math.pi * nu_y)
exp_compx_nu1 = exp_compx_nu1 - 1.0
exp_compx_nu1 = 1.0 / exp_compx_nu1
exp_compx_nu2 = complex_exp(-2.0 * math.pi * nu_y)
exp_compx_nu2 = exp_compx_nu2 - 1.0
exp_compx_nu2 = 1.0 / exp_compx_nu2
fy_z = fy(beta_y, mu_y)
fy_z_conj = fy_conjugate(fy_z)
d_fy_z = fy_derivative(beta_y, mu_y, alpha_y)
d_fy_z_conj = fy_conjugate(d_fy_z)
len_dfy = len(d_fy_z)
d_fy_z_avg = np.zeros(len_dfy, dtype=complex)
d_fy_z_avg[0] = d_fy_z[0]
for i in range(len_dfy - 1):
d_fy_z_avg[i + 1] = 0.5 * (d_fy_z[i] + d_fy_z[i + 1])
d_fy_z_conj_avg = fy_conjugate(d_fy_z_avg)
psi = psi_z(gamma, B_moment_anomaly, zeta, angle)
complx_exp_psi = complex_exp_psi(psi)
G1j = np.zeros(len_dfy, dtype=complex)
# G1j[0] = d_fy_z_avg[0] * cos(alpha_snake * ( 1 - zeta[0])) * (complx_exp_psi[0] - complx_exp_psi[0])
for i in range(len_dfy - 1):
G1j[i + 1] = d_fy_z_avg[i + 1] * cos(
alpha_snake *
(1 - zeta[i + 1])) * (complx_exp_psi[i + 1] - complx_exp_psi[i])
SUM_G1j = np.zeros(len_dfy, dtype=complex)
SUM_G1j[0] = G1j[0]
for i in range(len_dfy - 1):
SUM_G1j[i + 1] = G1j[i + 1] + SUM_G1j[i]
G2j = np.zeros(len_dfy, dtype=complex)
# G2j[0] = d_fy_z_conj_avg[0] * cos(alpha_snake * ( 1 - zeta[0])) * (complx_exp_psi[0] - complx_exp_psi[0])
for i in range(len_dfy - 1):
G2j[i + 1] = d_fy_z_conj_avg[i + 1] * cos(
alpha_snake *
(1 - zeta[i + 1])) * (complx_exp_psi[i + 1] - complx_exp_psi[i])
SUM_G2j = np.zeros(len_dfy, dtype=complex)
SUM_G2j[0] = G2j[0]
for i in range(len_dfy - 1):
SUM_G2j[i + 1] = G2j[i + 1] + SUM_G2j[i]
F1j_const = exp_compx_nu1 * SUM_G1j[len_dfy - 1]
F2j_const = exp_compx_nu2 * SUM_G2j[len_dfy - 1]
F1j = np.zeros(len_dfy, dtype=complex)
for i in range(len_dfy):
F1j[i] = SUM_G1j[i] + F1j_const
F2j = np.zeros(len_dfy, dtype=complex)
for i in range(len_dfy):
F2j[i] = SUM_G2j[i] + F2j_const
F3 = np.zeros(len_dfy, dtype=complex)
for i in range(len_dfy):
F3[i] = gamma * B_moment_anomaly / complex(
0.0, 2.0) * (fy_z_conj[i] * F1j[i] - fy_z[i] * F2j[i])
F3 = np.absolute(F3)
length_F = len(F3)
For_dipoles = np.zeros(len_dfy)
for i in range(len_dfy):
For_dipoles[i] = (angle[i] * delta_phi * 0.001)**2.0
For_quadrupoles = np.zeros(len_dfy)
for i in range(len_dfy):
For_quadrupoles[i] = (K1_L[i] * delta_y * 0.001)**2.0
SUM_D_and_Q = np.zeros(len_dfy)
for i in range(len_dfy):
SUM_D_and_Q[i] = For_dipoles[i] + For_quadrupoles[i]
element_of_strength = np.zeros(len_dfy)
for i in range(len_dfy):
element_of_strength[i] = F3[i]**2 * SUM_D_and_Q[i]
Zero_integer_SRS = np.sum(element_of_strength)
Zero_integer_SRS = 0.5 * math.sqrt(Zero_integer_SRS) / math.pi
return S, F3, Zero_integer_SRS
def calcError(self, input, target): output = self.run(input) diff = np.absolute(output-target) return np.average(diff)
def index_finder(phi, phi_c):
i = np.argmin(np.absolute(phi - phi_c))
return i
# #np.take(np.take(S[i,k,1+3*j], range(dims[j]/2,dims[j]), axis=0), range(dims[j]/2), axis=1)
# S[i,k,1+3*j][dims[j]/2:dims[j],0:dims[j]/2]
# )
# # make numpy-array of t_amps, only valid for first three indices,
# # because then, the dimensions of the matrices change, generally
# t = np.array(t)
# t = np.reshape(t, (nr,nfreq,nconf))
t = np.zeros((nr, nfreq, nconf, nin_max, nin_max), dtype='complex')
for i in range(nr):
for j in range(nfreq):
for k in range(nconf):
t[i,j,k,0:nins[j],0:nins[j]] = S[i,k,1+3*j][nins[j]:2*nins[j],0:nins[j]]
transmissions = np.array([[
np.mean(np.absolute(t[i,j,:,:])) * nin_max**2 / nins[j]
for j in range(nfreq)] for i in range(nr)])
#print transmissions
trans_mean = np.array([[
np.mean(np.absolute(t[i,j,:,:])) * nin_max**2 / nins[j]**2
for j in range(nfreq)] for i in range(nr)])
#print trans_mean
trans_msqr = np.array([[
np.mean(np.absolute(t[i,j,:,:])**2) * nin_max**2 / nins[j]**2
for j in range(nfreq)] for i in range(nr)])
#print trans_msqr
print (trans_msqr - trans_mean**2) / transmissions**2
def calcTransformError(self, input, target): output = self.run(input) output[output >= 0] = 1 output[output <= 0 ] = -1 diff = np.absolute(output - target) return np.average(diff)
vis = img.copy()
'''
finding gradient by Sobel filter
'''
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
useGradient = 0
if useGradient:
gradX = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=3)
'''
take absolute value of gradient to use negative gradient
'''
gradX = np.absolute(gradX)
'''
Normalization of gradient
'''
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
if maxVal - minVal > 0:
gradX = (255 * ((gradX - minVal) / float(maxVal - minVal))).astype("uint8")
else:
gradX = np.zeros(gray.shape, dtype = "uint8")
else:
gradX = 255 - gray
'''
Take median filter by horizontal axis
'''
def errorCalc(self, input, target): result = self.run(input) diff = np.absolute(result-target) return np.average(diff)
def test_constantFaces(self):
face_vec = np.ones(self.mesh.nF)
assert all(np.absolute(self.mesh.aveF2CC * face_vec - 1.) < TOL)
assert all(np.absolute(self.mesh.aveF2CCV * face_vec - 1.) < TOL)
y_pred_train = regr.predict(X_train)
y_pred_test = regr.predict(X_test)
y_pred_train2 = regr2.predict(X_train2)
y_pred_test2 = regr2.predict(X_test2)
y_pred_train3 = regr3.predict(X_train3)
y_pred_test3 = regr3.predict(X_test3)
y_pred_train4 = regr4.predict(X_train4)
y_pred_test4 = regr4.predict(X_test4)
y_pred_train5 = regr5.predict(X_train5)
y_pred_test5 = regr5.predict(X_test5)
columns = ['Model', 'Train error', 'Test error', 'Sum of Absolute Weights']
model1 = "%.2f X + %.2f" % (regr.coef_[0][0], regr.intercept_[0])
values1 = [model1, np.sqrt(mean_squared_error(y_train, y_pred_train)), np.sqrt(mean_squared_error(y_test, y_pred_test)),
np.absolute(regr.coef_[0]).sum() + np.absolute(regr.intercept_[0])]
model2 = "%.2f X + %.2f X2 + %.2f" % (regr2.coef_[0][0], regr2.coef_[0][1], regr2.intercept_[0])
values2 = [model2, np.sqrt(mean_squared_error(y_train, y_pred_train2)),
np.sqrt(mean_squared_error(y_test, y_pred_test2)),
np.absolute(regr2.coef_[0]).sum() + np.absolute(regr2.intercept_[0])]
model3 = "%.2f X + %.2f X2 + %.2f X3 + %.2f" % (
regr3.coef_[0][0], regr3.coef_[0][1], regr3.coef_[0][2], regr3.intercept_[0])
values3 = [model3, np.sqrt(mean_squared_error(y_train, y_pred_train3)),
np.sqrt(mean_squared_error(y_test, y_pred_test3)),
np.absolute(regr3.coef_[0]).sum() + np.absolute(regr3.intercept_[0])]
model4 = "%.2f X + %.2f X2 + %.2f X3 + %.2f X4 + %.2f" % (regr4.coef_[0][0], regr4.coef_[0][1],
regr4.coef_[0][2], regr4.coef_[0][3], regr4.intercept_[0])
values4 = [model4, np.sqrt(mean_squared_error(y_train, y_pred_train4)),
np.sqrt(mean_squared_error(y_test, y_pred_test4)),
np.absolute(regr4.coef_[0]).sum() + np.absolute(regr4.intercept_[0])]
model5 = "%.2f X + %.2f X2 + %.2f X3 + %.2f X4 + %.2f X5 + %.2f" % (
def perception_step(Rover):
# Perform perception steps to update Rover()
# TODO:
# NOTE: camera image is coming to you in Rover.img
# 1) Define source and destination points for perspective transform
dst_size = 5
bottom_offset = 6
image = Rover.img
source = np.float32([[14, 140], [301 ,140],[200, 96], [118, 96]])
destination = np.float32([[image.shape[1]/2 - dst_size, image.shape[0] - bottom_offset],
[image.shape[1]/2 + dst_size, image.shape[0] - bottom_offset],
[image.shape[1]/2 + dst_size, image.shape[0] - 2*dst_size - bottom_offset],
[image.shape[1]/2 - dst_size, image.shape[0] - 2*dst_size - bottom_offset],
])
# 2) Apply perspective transform
warped, mask = perspect_transform(image, source, destination)
# 3) Apply color threshold to identify navigable terrain/obstacles/rock samples
color_select = color_thresh(warped, rgb_thresh=(160,160,160))
obstacle = np.absolute(np.float32(color_select) -1) * mask
rock = rock_thresh(warped)
# 4) Update Rover.vision_image (this will be displayed on left side of screen)
# Example: Rover.vision_image[:,:,0] = obstacle color-thresholded binary image
# Rover.vision_image[:,:,1] = rock_sample color-thresholded binary image
# Rover.vision_image[:,:,2] = navigable terrain color-thresholded binary image
Rover.vision_image[:,:,0] = obstacle * 255
Rover.vision_image[:,:,1] = rock * 255
Rover.vision_image[:,:,2] = color_select * 255
# 5) Convert map image pixel values to rover-centric coords
x_pix, y_pix = rover_coords(color_select)
obsxpix, obsypix = rover_coords(obstacle)
rockxpix, rockypix = rover_coords(rock)
# 6) Convert rover-centric pixel values to world coordinates
world_size = Rover.worldmap.shape[0]
scale = 2 * dst_size
xpos, ypos = Rover.pos[0], Rover.pos[1]
yaw = Rover.yaw
xpix_world, ypix_world = pix_to_world(x_pix, y_pix, xpos, ypos, yaw, world_size, scale)
rockxpix_world, rockypix_world = pix_to_world(rockxpix, rockypix, xpos, ypos, yaw, world_size, scale)
obsxpix_world, obsypix_world = pix_to_world(obsxpix, obsypix, xpos, ypos, yaw, world_size, scale)
# 7) Update Rover worldmap (to be displayed on right side of screen)
# Example: Rover.worldmap[obstacle_y_world, obstacle_x_world, 0] += 1
# Rover.worldmap[rock_y_world, rock_x_world, 1] += 1
# Rover.worldmap[navigable_y_world, navigable_x_world, 2] += 1
Rover.worldmap[obsypix_world, obsxpix_world, 0] += 255
Rover.worldmap[rockypix_world, rockxpix_world, 1] += 255
Rover.worldmap[ypix_world, xpix_world, 2] += 255
if len(rockxpix) > 5:
rock_dist, rock_angles = to_polar_coords(rockxpix, rockypix)
Rover.sample_angles = rock_angles
Rover.sample_dists = rock_dist
Rover.sample_seen = True
# 8) Convert rover-centric pixel positions to polar coordinates
dist, angles = to_polar_coords(x_pix, y_pix)
# Update Rover pixel distances and angles
# Rover.nav_dists = rover_centric_pixel_distances
# Rover.nav_angles = rover_centric_angles
Rover.nav_dists = dist
Rover.nav_angles = angles
return Rover
#Simple Regression Model
#Train data distribution
plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')
plt.xlabel("Engine size")
plt.ylabel("Emission")
plt.show()
# Modeling
from sklearn import linear_model
regr = linear_model.LinearRegression()
train_x = np.asanyarray(train[['ENGINESIZE']])
train_y = np.asanyarray(train[['CO2EMISSIONS']])
regr.fit (train_x, train_y)
# The coefficients
print ('Coefficients: ', regr.coef_)
print ('Intercept: ',regr.intercept_)
plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')
plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')
plt.xlabel("Engine size")
plt.ylabel("Emission")
# Evaluation
from sklearn.metrics import r2_score
test_x = np.asanyarray(test[['ENGINESIZE']])
test_y = np.asanyarray(test[['CO2EMISSIONS']])
test_y_hat = regr.predict(test_x)
print("Mean absolute error: %.2f" % np.mean(np.absolute(test_y_hat - test_y)))
print("Residual sum of squares (MSE): %.2f" % np.mean((test_y_hat - test_y) ** 2))
print("R2-score: %.2f" % r2_score(test_y_hat , test_y) )
def robustProcess(
self, numWindows: int, obs: np.ndarray, reg: np.ndarray
) -> Tuple[np.ndarray]:
"""Robust regression processing
Perform robust regression processing using observations and regressors for a single evaluation frequency.
Parameters
----------
numWindows : int
The number of windows
obs : np.ndarray
The observations
reg : np.ndarray
The regressors
Returns
-------
output : np.ndarray
The solution to the regression problem
varOutput : np.ndarray
The variance
"""
# create array for output
output = np.empty(shape=(self.outSize, self.inSize), dtype="complex")
varOutput = np.empty(shape=(self.outSize, self.inSize), dtype="float")
# solve
for i in range(0, self.outSize):
observation = obs[i, :]
predictors = reg[i, :, :]
# save the output
out, resids, weights = chatterjeeMachler(
predictors, observation, intercept=self.intercept
)
# out, resids, scale, weights = mmestimateModel(predictors, observation, intercept=self.intercept)
# now take the weights, apply to the observations and predictors, stack the appropriate rows and test
observation2 = np.zeros(shape=(self.remoteSize), dtype="complex")
predictors2 = np.zeros(
shape=(self.remoteSize, self.inSize), dtype="complex"
)
for iChan in range(0, self.remoteSize):
# now need to have my indexing array
indexArray = np.arange(
iChan, numWindows * self.remoteSize, self.remoteSize
)
weightsLim = weights[indexArray]
# weightsLim = weightsLim/np.sum(weightsLim) # normalise weights to 1
observation2[iChan] = (
np.sum(obs[i, indexArray] * weightsLim) / numWindows
)
# now for the regressors
for j in range(0, self.inSize):
predictors2[iChan, j] = (
np.sum(reg[i, indexArray, j] * weightsLim) / numWindows
)
out, resids, weights = chatterjeeMachler(
predictors2, observation2, intercept=self.intercept
)
# out, resids, scale, weights = mmestimateModel(predictors2, observation2, intercept=self.intercept)
# now calculate out the varainces - have the solution out, have the weights
# recalculate out the residuals with the final solution
# calculate standard deviation of residuals
# and then use chatterjee machler formula to estimate variances
# this needs work - better to use an empirical bootstrap method, but this will do for now
resids = np.absolute(observation - np.dot(predictors, out))
scale = sampleMAD0(
resids
) # some measure of standard deviation, rather than using the standard deviation
residsVar = scale * scale
varPred = np.dot(hermitianTranspose(predictors), weights * predictors)
varPred = np.linalg.inv(varPred) # this is a pxp matrix
varOut = 1.91472 * residsVar * varPred
varOut = np.diag(varOut).real # this should be a real number
if self.intercept:
output[i] = out[1:]
varOutput[i] = varOut[1:]
else:
output[i] = out
varOutput[i] = varOut
return output, varOutput
def test_constantEdges(self):
edge_vec = np.ones(self.mesh.nE)
assert all(np.absolute(self.mesh.aveE2CC * edge_vec - 1.) < TOL)
assert all(np.absolute(self.mesh.aveE2CCV * edge_vec - 1.) < TOL)
def train_mfn_phantom(X_train, y_train, X_valid, y_valid, X_test, y_test, configs, mode, save_path):
p = np.random.permutation(X_train.shape[0])
X_train = X_train[p]
y_train = y_train[p]
X_train = X_train.swapaxes(0,1)
X_valid = X_valid.swapaxes(0,1)
X_test = X_test.swapaxes(0,1)
d = X_train.shape[2]
h = 128
t = X_train.shape[0]
output_dim = 1
dropout = 0.5
[config,NN1Config,NN2Config,gamma1Config,gamma2Config,outConfig] = configs
#model = EFLSTM(d,h,output_dim,dropout)
model = MFNPhantom(config,NN1Config,NN2Config,gamma1Config,gamma2Config,outConfig, mode)
#optimizer = optim.SGD(model.parameters(),lr=config["lr"],momentum=config["momentum"])
# optimizer = optim.SGD([
# {'params':model.lstm_l.parameters(), 'lr':config["lr"]},
# {'params':model.classifier.parameters(), 'lr':config["lr"]}
# ], momentum=0.9)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
optimizer = optim.Adam(model.parameters(),lr=config["lr"])
scheduler = ReduceLROnPlateau(optimizer,mode='min',patience=100,factor=0.5,verbose=True)
best_valid = 999999.0
rand = random.randint(0,100000)
print 'model number is:', rand
model = torch.load('{}/mfn_phantom_{}.pt'.format(save_path, args.hparam_iter))
model.eval()
#model = copy.deepcopy(best_model).cpu().gpu()
#model.calc_phantom_corr(config["batchsize"], X_valid, y_valid, 'after')
for split in ['train', 'valid', 'test']:
if split is 'train':
X, y = X_train, y_train
elif split is 'valid':
X, y = X_valid, y_valid
else:
X, y = X_test, y_test
predictions = model.predict(X)
mae = np.mean(np.absolute(predictions-y))
print split, "mae: ", mae
corr = np.corrcoef(predictions,y)[0][1]
print split, "corr: ", corr
mult = round(sum(np.round(predictions)==np.round(y))/float(len(y)),5)
#print split, "mult_acc: ", mult
f_score = round(f1_score(np.round(predictions),np.round(y),average='weighted'),5)
#print split, "mult f_score: ", f_score
true_label = (y >= 0)
predicted_label = (predictions >= 0)
#print split, "Confusion Matrix :"
#print confusion_matrix(true_label, predicted_label)
#print split, "Classification Report :"
#print classification_report(true_label, predicted_label, digits=5)
#print split, "Accuracy ", accuracy_score(true_label, predicted_label)
sys.stdout.flush()
def fit_Lorentzian(data_dir, primary_bounds, seeded_bounds):
x = np.load(data_dir + 'freqs.npy')
y = np.load(data_dir + 'PSD_data.npy')
peaks, _ = scipy.signal.find_peaks(y, distance=5)
pLboundInd = np.argmin(np.absolute(x / 1.e6 - primary_bounds[0]))
pRboundInd = np.argmin(np.absolute(x / 1.e6 - primary_bounds[1]))
pPeakInd = np.argmax(y[pLboundInd:pRboundInd])
sLboundInd = np.argmin(np.absolute(x / 1.e6 - seeded_bounds[0]))
sRboundInd = np.argmin(np.absolute(x / 1.e6 - seeded_bounds[1]))
sPeakInd = np.argmax(y[sLboundInd:sRboundInd])
# tP = np.linspace(x[pLboundInd],x[pRboundInd],1000)/1e6
# tS = np.linspace(x[sLboundInd],x[sRboundInd],1000)/1e6
# pBounds = ([0., 0., 0.],[np.inf, np.inf, np.inf])
# sBounds = ([0., 0., 0.],[np.inf, np.inf, np.inf])
#
bothBounds = (0., np.inf) # Test Dual Fit
# p0P = [y[pLboundInd:pRboundInd][pPeakInd], 10., x[pLboundInd:pRboundInd][pPeakInd]]
# p0S = [y[sLboundInd:sRboundInd][sPeakInd], 10., x[sLboundInd:sRboundInd][sPeakInd]]
#
p0Both = [
y[pLboundInd:pRboundInd][pPeakInd], 2.,
x[pLboundInd:pRboundInd][pPeakInd], y[sLboundInd:sRboundInd][sPeakInd],
2., x[sLboundInd:sRboundInd][sPeakInd], 23.
] # Test Dual Fit
# poptP, pcovP = scipy.optimize.curve_fit(lorentzian, x[pLboundInd:pRboundInd], y[pLboundInd:pRboundInd], p0 = p0P, bounds = bothBounds)
# poptS, pcovS = scipy.optimize.curve_fit(lorentzian, x[sLboundInd:sRboundInd], y[sLboundInd:sRboundInd], p0 = p0S, bounds = bothBounds)
#
poptBoth, pcovBoth = scipy.optimize.curve_fit(
double_lorentzian, x, y, p0=p0Both, bounds=bothBounds) # Test Dual Fit
# poptP = np.array(poptP)
# poptS = np.array(poptS)
#
poptBoth = np.array(poptBoth) # Test Dual Fit
p_sigma = np.sqrt(np.diag(pcovBoth))
# poptP[1:] *= 1.e-6
# poptS[1:] *= 1.e-6
#
poptBoth[1:3] *= 1.e-6 # Test Dual Fit
poptBoth[4:6] *= 1.e-6 # Test Dual Fit
p_sigma[1:3] *= 1.e-6
p_sigma[4:6] *= 1.e-6
# plt.plot(tP, lorentzian(tP, *poptP), c='purple')
# plt.plot(tS, lorentzian(tS, *poptS), c='green')
# plt.show(block=True)
#
return [
poptBoth, p_sigma
] #[poptP, pcovP], [poptS, pcovS], [poptBoth, pcovBoth] # Test Dual Fit
def power_spectrum(waves, n=None):
if n == None:
n = waves.shape[-1]
mag_spec = np.absolute(np.fft.rfft(waves, n))
return 1.0 / n * np.square(mag_spec)
def ecc_plot(aryMean, vecEccBin, strPathOut):
"""
Plot results for eccentricity & cortical depth analysis.
This version plots the values using two separate colourmaps for negative
and positive values.
Plots statistical parameters (e.g. parameter estimates) by cortical depth
(x-axis) and pRF eccentricity (y-axis). This function is part of a tool for
analysis of cortical-depth-dependent fMRI responses at different
retinotopic eccentricities.
"""
# Number of eccentricity bins:
varEccNum = vecEccBin.shape[0]
# Font type:
strFont = 'Liberation Sans'
# Font colour:
vecFontClr = np.array([17.0/255.0, 85.0/255.0, 124.0/255.0])
# Find minimum and maximum correlation values:
varMin = np.percentile(aryMean, 2.5)
varMax = np.percentile(aryMean, 97.5)
# Round:
varMin = (np.floor(varMin * 0.1) / 0.1)
varMax = (np.ceil(varMax * 0.1) / 0.1)
# Same scale for negative and positive colour bar:
if np.greater(np.absolute(varMin), varMax):
varMax = np.absolute(varMin)
else:
varMin = np.multiply(-1.0, np.absolute(varMax))
# Fixed axis limites for comparing plots across conditions/ROIs:
# varMin = -400.0
# varMax = 400.0
# Create main figure:
fig01 = plt.figure(figsize=(4.0, 3.0),
dpi=200.0,
facecolor=([1.0, 1.0, 1.0]),
edgecolor=([1.0, 1.0, 1.0]))
# Big subplot in the background for common axes labels:
axsCmn = fig01.add_subplot(111)
# Turn off axis lines and ticks of the big subplot:
axsCmn.spines['top'].set_color('none')
axsCmn.spines['bottom'].set_color('none')
axsCmn.spines['left'].set_color('none')
axsCmn.spines['right'].set_color('none')
axsCmn.tick_params(labelcolor='w',
top=False,
bottom=False,
left=False,
right=False)
# Set and adjust common axes labels:
axsCmn.set_xlabel('Cortical depth',
alpha=1.0,
fontname=strFont,
fontweight='normal',
fontsize=7.0,
color=vecFontClr,
position=(0.5, 0.0))
axsCmn.set_ylabel('pRF eccentricity',
alpha=1.0,
fontname=strFont,
fontweight='normal',
fontsize=7.0,
color=vecFontClr,
position=(0.0, 0.5))
axsCmn.set_title('fMRI signal change',
alpha=1.0,
fontname=strFont,
fontweight='bold',
fontsize=10.0,
color=vecFontClr,
position=(0.5, 1.1))
# Create colour-bar axis:
axsTmp = fig01.add_subplot(111)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Number of colour increments:
varNumClr = 20
# Colour values for the first colormap (used for negative values):
aryClr01 = plt.cm.PuBu(np.linspace(0.1, 1.0, varNumClr))
# Invert the first colour map:
aryClr01 = np.flipud(np.array(aryClr01, ndmin=2))
# Colour values for the second colormap (used for positive values):
aryClr02 = plt.cm.OrRd(np.linspace(0.1, 1.0, varNumClr))
# Combine negative and positive colour arrays:
aryClr03 = np.vstack((aryClr01, aryClr02))
# Create new custom colormap, combining two default colormaps:
objCustClrMp = colors.LinearSegmentedColormap.from_list('custClrMp',
aryClr03)
# Lookup vector for negative colour range:
vecClrRngNeg = np.linspace(varMin, 0.0, num=varNumClr)
# Lookup vector for positive colour range:
vecClrRngPos = np.linspace(0.0, varMax, num=varNumClr)
# Stack lookup vectors:
vecClrRng = np.hstack((vecClrRngNeg, vecClrRngPos))
# 'Normalize' object, needed to use custom colour maps and lookup table
# with matplotlib:
objClrNorm = colors.BoundaryNorm(vecClrRng, objCustClrMp.N)
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Plot correlation coefficients of current depth level:
pltTmpCorr = plt.imshow(aryMean,
interpolation='nearest', # 'none', # 'bicubic',
origin='lower',
norm=objClrNorm,
cmap=objCustClrMp)
# Position of labels for the x-axis:
vecXlblsPos = np.array([0, (aryMean.shape[1] - 1)])
# Set position of labels for the x-axis:
axsTmp.set_xticks(vecXlblsPos)
# Create list of strings for labels:
lstXlblsStr = ['WM', 'CSF']
# Set the content of the labels (i.e. strings):
axsTmp.set_xticklabels(lstXlblsStr,
alpha=0.9,
fontname=strFont,
fontweight='bold',
fontsize=8.0,
color=vecFontClr)
# Position of labels for the y-axis:
vecYlblsPos = np.arange(-0.5, (varEccNum - 0.5), 1.0)
# Set position of labels for the y-axis:
axsTmp.set_yticks(vecYlblsPos)
# Create list of strings for labels:
# lstYlblsStr = map(str,
# np.around(vecEccBin, decimals=1)
# )
lstYlblsStr = [str(x) for x in np.around(vecEccBin, decimals=1)]
# Set the content of the labels (i.e. strings):
axsTmp.set_yticklabels(lstYlblsStr,
alpha=0.9,
fontname=strFont,
fontweight='bold',
fontsize=8.0,
color=vecFontClr)
# Turn of ticks:
axsTmp.tick_params(labelcolor=([0.0, 0.0, 0.0]),
top=False,
bottom=False,
left=False,
right=False)
# We create invisible axes for the colour bar slightly to the right of the
# position of the last data-axes. First, retrieve position of last
# data-axes:
objBbox = axsTmp.get_position()
# We slightly adjust the x-position of the colour-bar axis, by shifting
# them to the right:
vecClrAxsPos = np.array([(objBbox.x0 * 7.5),
objBbox.y0,
objBbox.width,
objBbox.height])
# Create colour-bar axis:
axsClr = fig01.add_axes(vecClrAxsPos,
frameon=False)
# Add colour bar:
pltClrbr = fig01.colorbar(pltTmpCorr,
ax=axsClr,
fraction=1.0,
shrink=1.0)
# The values to be labeled on the colour bar:
# vecClrLblsPos01 = np.arange(varMin, 0.0, 10)
# vecClrLblsPos02 = np.arange(0.0, varMax, 100)
vecClrLblsPos01 = np.linspace(varMin, 0.0, num=3)
vecClrLblsPos02 = np.linspace(0.0, varMax, num=3)
vecClrLblsPos = np.hstack((vecClrLblsPos01, vecClrLblsPos02))
# The labels (strings):
# vecClrLblsStr = map(str, vecClrLblsPos)
vecClrLblsStr = [str(x) for x in vecClrLblsPos]
# Set labels on coloubar:
pltClrbr.set_ticks(vecClrLblsPos)
pltClrbr.set_ticklabels(vecClrLblsStr)
# Set font size of colour bar ticks, and remove the 'spines' on the right
# side:
pltClrbr.ax.tick_params(labelsize=8.0,
tick2On=False)
# Make colour-bar axis invisible:
axsClr.axis('off')
# Save figure:
fig01.savefig(strPathOut,
dpi=160.0,
facecolor='w',
edgecolor='w',
orientation='landscape',
bbox_inches='tight',
pad_inches=0.2,
transparent=False,
frameon=None)
def birds_eye_height_slices(
points,
n_slices=8,
height_range=(-2.73, 1.27),
side_range=(-10, 10),
fwd_range=(-10, 10),
res=0.1,
time_stamp=None,
):
""" Creates an array that is a birds eye view representation of the
reflectance values in the point cloud data, separated into different
height slices.
Args:
points: (numpy array)
Nx4 array of the points cloud data.
N rows of points. Each point represented as 4 values,
x,y,z, reflectance
n_slices : (int)
Number of height slices to use.
height_range: (tuple of two floats)
(min, max) heights (in metres) relative to the sensor.
The slices calculated will be within this range, plus
two additional slices for clipping all values below the
min, and all values above the max.
Default is set to (-2.73, 1.27), which corresponds to a
range of -1m to 3m above a flat road surface given the
configuration of the sensor in the Kitti dataset.
side_range: (tuple of two floats)
(-left, right) in metres
Left and right limits of rectangle to look at.
Defaults to 10m on either side of the car.
fwd_range: (tuple of two floats)
(-behind, front) in metres
back and front limits of rectangle to look at.
Defaults to 10m behind and 10m in front.
res: (float) desired resolution in metres to use
Each output pixel will represent an square region res x res
in size along the front and side plane.
"""
x_points = points[:, 0]
y_points = points[:, 1]
z_points = points[:, 2]
i_points = points[:, 3] # Reflectance
# FILTER INDICES - of only the points within the desired rectangle
# Note left side is positive y axis in LIDAR coordinates
ff = np.logical_and((x_points > fwd_range[0]), (x_points < fwd_range[1]))
ss = np.logical_and((y_points > -side_range[1]),
(y_points < -side_range[0]))
indices = np.argwhere(np.logical_and(ff, ss)).flatten()
# KEEPERS - The actual points that are within the desired rectangle
y_points = y_points[indices]
x_points = x_points[indices]
z_points = z_points[indices]
i_points = i_points[indices]
# CONVERT TO PIXEL POSITION VALUES - Based on resolution
x_img = (-y_points / res).astype(np.int32) # x axis is -y in LIDAR
y_img = (x_points / res).astype(np.int32) # y axis is -x in LIDAR
# direction to be inverted later
# SHIFT PIXELS TO HAVE MINIMUM BE (0,0)
# floor used to prevent issues with -ve vals rounding upwards
x_img -= int(np.floor(side_range[0] / res))
y_img -= int(np.floor(fwd_range[0] / res))
# ASSIGN EACH POINT TO A HEIGHT SLICE
# n_slices-1 is used because values above max_height get assigned to an
# extra index when we call np.digitize().
bins = np.linspace(height_range[0], height_range[1], num=n_slices - 1)
slice_indices = np.digitize(z_points, bins=bins, right=False)
# RESCALE THE REFLECTANCE VALUES - to be between the range 0-255
pixel_values = scale_to_255(i_points, min=0.0, max=255.0)
# FILL PIXEL VALUES IN IMAGE ARRAY
# -y is used because images start from top left
x_max = int((side_range[1] - side_range[0]) / res)
y_max = int((fwd_range[1] - fwd_range[0]) / res)
im = np.zeros([y_max, x_max, n_slices], dtype=np.uint8)
im[-y_img, x_img, slice_indices] = pixel_values
#for i in range(0,8):
#cv2.imshow("image_raw %d"%(0), cv2.pyrDown(im[:,:,0]))
minx = 9999999999
count = 0
tracklet = featurerecord.tracklet
for i in range(1, len(tracklet)):
if np.absolute(tracklet[i][0] - time_stamp
) < minx: #and tracklet[i][0] - time_stamp >= 0:
minx = np.absolute(tracklet[i][0] - time_stamp)
count = i
tracklet = np.vstack((tracklet[:12], tracklet))
if count < 12:
count = 1
#tracklet = tracklet[12:]
centPoint = np.array(
[tracklet[count][1], tracklet[count][2], tracklet[count][3]])
print(centPoint)
#obslwh = np.array([4.2418, 1.4478, 1.5748])
#obslwh = np.array([4.191, 1.5748, 1.524])
obslwh = np.array([4.5212, 1.7018, 1.397])
obslwh += np.array([1, 0.8, 0.4])
obslwh = obslwh / 2
x = np.array([centPoint[1] - obslwh[1], centPoint[1] + obslwh[1]])
y = np.array([centPoint[0] - obslwh[0], centPoint[0] + obslwh[0]])
xp = (-x / res).astype(np.int32) # x axis is -y in LIDAR
yp = (-y / res).astype(np.int32) # y axis is -x in LIDAR
xp -= int(np.floor(side_range[0] / res))
yp -= int(np.floor(fwd_range[0] / res))
xp = np.clip(xp, 0, x_max)
yp = np.clip(yp, 0, y_max)
boundingbox = np.array([
xp[1], yp[1], xp[0], yp[0], centPoint[0], centPoint[1], centPoint[2],
obslwh[0], obslwh[1], obslwh[2]
],
dtype=np.float)
return im, boundingbox
newD = newD['fibergraph']
newD = newD.todense()
print newD
#newD = np.delete(newD,0,1)
#newD = np.delete(newD,0,0)
oldD = genfromtxt(old_file, delimiter=' ')
oldD = np.delete(oldD, 0, 1)
oldD = np.delete(oldD, 0, 0)
diff = np.subtract(newD, oldD)
absdiff = np.absolute(diff)
result = np.divide(absdiff, oldD)
resultArray = np.add(diff, resultArray)
#np.savetxt((outputDir + "analysis" + str(counter) + ".csv"), result, delimiter=",")
#counter = counter + 1
tempRow = list()
subject = os.path.realpath(new_file)
subject = subject[(subject.rfind('/') + 1):]
subject = subject[:10]
tempRow.append(subject)
def chapter10and11(bAwImg):
#finds the edges in the image
#this edge detection didnt work very well
#too sensitive
# edgedImg = cv2.Canny(bAwImg, 5, 250)
# cv2.imshow("canny edge", edgedImg)
image = bAwImg
#image, data type, and then derivatives
#1,0 for vertical edges
#0,1 for horizontal edges
#this works better for edges
sobelX = cv2.Sobel(image, cv2.CV_64F, 1, 0)
sobelY = cv2.Sobel(image, cv2.CV_64F, 0, 1)
sobelX = np.uint8(np.absolute(sobelX))
sobelY = np.uint8(np.absolute(sobelY))
#or so that all edges are included
comb = cv2.bitwise_or(sobelX, sobelY)
#reverse it
comb = cv2.bitwise_not(comb)
cv2.imshow("edges with sobel", comb)
cv2.waitKey()
image = comb.copy()
count1 = perf_counter()
#LOOP THROUGH MANUALLY
h, w = comb.shape[:2]
#left edge finder
leftCounter = 0
leftTotal = 0
for y in range(h):
#try is to find the other side of an edge
TRY = False
#found is for confirming a find
FOUND = False
for x in range(w):
#goes downwards toward the right
color = comb[y - 1, x - 1]
#if it finds a black, it will be ready to search
if color > 240 and TRY == False and FOUND == False:
TRY = True
# print(x-1)
if TRY == True and FOUND == False:
#will search for the white part of the line to see if it is indeed an edge
for n in range(5):
if x + n < w:
color = comb[y - 1, x + n]
if color < 240:
FOUND = True
leftCounter += x - 1
leftTotal += 1.0
break
#once the edge is found, this loop ends
if FOUND == True:
continue
leftAvg = leftCounter / leftTotal
print(f"left bound = {leftAvg}")
#right edge finder
rightCounter = 0
rightTotal = 0
for y in range(h):
#try is to find the other side of an edge
TRY = False
#found is for confirming a find
FOUND = False
for x in range(w):
#goes downwards toward the left
color = comb[y - 1, w - x - 1]
#if it finds a black, it will be ready to search
if color > 240 and TRY == False and FOUND == False:
TRY = True
if TRY == True and FOUND == False:
#will search for the white part of the line to see if it is indeed an edge
for n in range(5):
if x - n > 0:
color = comb[y - 1, x - n - 1]
if color < 240:
FOUND = True
rightCounter += w - x - 1
rightTotal += 1.0
break
#once the edge is found, this loop ends
if FOUND == True:
continue
rightAvg = rightCounter / rightTotal
print(f"right bound = {rightAvg}")
#top edge finder
topCounter = 0
topTotal = 0
for x in range(w):
#try is to find the other side of an edge
TRY = False
#found is for confirming a find
FOUND = False
for y in range(h):
#goes rightwards toward the bottom
color = comb[y - 1, x - 1]
#if it finds a black, it will be ready to search
if color > 240 and TRY == False and FOUND == False:
TRY = True
if TRY == True and FOUND == False:
#will search for the white part of the line to see if it is indeed an edge
for n in range(5):
if y + n < h:
color = comb[y + n, x - 1]
if color < 240:
FOUND = True
topCounter += y - 1
topTotal += 1.0
break
#once the edge is found, this loop ends
if FOUND == True:
continue
topAvg = topCounter / topTotal
print(f"top bound = {topAvg}")
#bottom edge finder
bottomCounter = 0
bottomTotal = 0
for x in range(w):
#try is to find the other side of an edge
TRY = False
#found is for confirming a find
FOUND = False
for y in range(h):
#goes rightwards toward the bottom
color = comb[h - y - 1, x - 1]
#if it finds a black, it will be ready to search
if color > 240 and TRY == False and FOUND == False:
TRY = True
if TRY == True and FOUND == False:
#will search for the white part of the line to see if it is indeed an edge
for n in range(5):
if h - y - n > 0:
color = comb[h - y - n - 1, x - 1]
if color < 240:
FOUND = True
bottomCounter += h - y - 1
bottomTotal += 1.0
break
#once the edge is found, this loop ends
if FOUND == True:
continue
bottomAvg = bottomCounter / bottomTotal
print(f"bottom bound = {bottomAvg}")
count2 = perf_counter()
time = count2 - count1
print(f"total time without multiprocessing: {time}")
#https://stackoverflow.com/questions/32404825/how-to-run-multiple-functions-at-same-time
executors_list = []
cs = [[comb, "top"], [comb, "bottom"], [comb, "left"], [comb, "right"]]
with ThreadPoolExecutor(max_workers=4) as executor:
executors_list.append(executor.submit(edgeFind, cs[0]))
executors_list.append(executor.submit(edgeFind, cs[1]))
executors_list.append(executor.submit(edgeFind, cs[2]))
executors_list.append(executor.submit(edgeFind, cs[3]))
# for x in executors_list:
# print(x.result())
count3 = perf_counter()
time = count3 - count2
print(f"total time with multithreading: {time}")
cs = [[comb, "top"], [comb, "bottom"], [comb, "left"], [comb, "right"]]
with Pool(processes=4, maxtasksperchild=1) as pool:
results = pool.map(edgeFind, cs)
pool.close()
pool.join()
# print(results)
count4 = perf_counter()
time = count4 - count3
print(f"total time with multitprocessing: {time}")
# cv2.imshow("cropped homework", image)
#crops the image using the edges found
y2 = int(bottomAvg)
y1 = int(topAvg)
x1 = int(leftAvg)
x2 = int(rightAvg)
croppedImg = image[y1:y2, x1:x2]
cv2.imshow("cropped homework", croppedImg)
cv2.waitKey()
def gsr_preprocessing(signals):
''' Preprocessing for GSR signals '''
der_signals = np.gradient(signals)
con_signals = 1.0 / signals
nor_con_signals = (con_signals -
np.mean(con_signals)) / np.std(con_signals)
mean = np.mean(signals)
der_mean = np.mean(der_signals)
neg_der_mean = np.mean(der_signals[der_signals < 0])
neg_der_pro = float(der_signals[der_signals < 0].size) / float(
der_signals.size)
local_min = 0
for i in range(signals.shape[0] - 1):
if i == 0:
continue
if signals[i - 1] > signals[i] and signals[i] < signals[i + 1]:
local_min += 1
# Using SC calculates rising time
det_nor_signals, trend = detrend(nor_con_signals)
lp_det_nor_signals = butter_lowpass_filter(det_nor_signals, 0.5, 128.)
der_lp_det_nor_signals = np.gradient(lp_det_nor_signals)
rising_time = 0
rising_cnt = 0
for i in range(der_lp_det_nor_signals.size - 1):
if der_lp_det_nor_signals[i] > 0:
rising_time += 1
if der_lp_det_nor_signals[i + 1] < 0:
rising_cnt += 1
avg_rising_time = rising_time * (1. / 128.) / rising_cnt
freqs, power = getfreqs_power(signals,
fs=128.,
nperseg=signals.size,
scaling='spectrum')
power_0_24 = []
for i in range(12):
power_0_24.append(
getBand_Power(freqs,
power,
lower=0 + (i * 0.2),
upper=0.2 + (i * 0.2)))
SCSR, _ = detrend(butter_lowpass_filter(nor_con_signals, 0.2, 128.))
SCVSR, _ = detrend(butter_lowpass_filter(nor_con_signals, 0.08, 128.))
zero_cross_SCSR = 0
zero_cross_SCVSR = 0
peaks_cnt_SCSR = 0
peaks_cnt_SCVSR = 0
peaks_value_SCSR = 0.
peaks_value_SCVSR = 0.
zc_idx_SCSR = np.array([], int) # must be int, otherwise it will be float
zc_idx_SCVSR = np.array([], int)
for i in range(nor_con_signals.size - 1):
if SCSR[i] * next((j for j in SCSR[i + 1:] if j != 0), 0) < 0:
zero_cross_SCSR += 1
zc_idx_SCSR = np.append(zc_idx_SCSR, i + 1)
if SCVSR[i] * next((j for j in SCVSR[i + 1:] if j != 0), 0) < 0:
zero_cross_SCVSR += 1
zc_idx_SCVSR = np.append(zc_idx_SCVSR, i)
for i in range(zc_idx_SCSR.size - 1):
peaks_value_SCSR += np.absolute(
SCSR[zc_idx_SCSR[i]:zc_idx_SCSR[i + 1]]).max()
peaks_cnt_SCSR += 1
for i in range(zc_idx_SCVSR.size - 1):
peaks_value_SCVSR += np.absolute(
SCVSR[zc_idx_SCVSR[i]:zc_idx_SCVSR[i + 1]]).max()
peaks_cnt_SCVSR += 1
zcr_SCSR = zero_cross_SCSR / (nor_con_signals.size / 128.)
zcr_SCVSR = zero_cross_SCVSR / (nor_con_signals.size / 128.)
mean_peak_SCSR = peaks_value_SCSR / peaks_cnt_SCSR if peaks_cnt_SCSR != 0 else 0
mean_peak_SCVSR = peaks_value_SCVSR / peaks_cnt_SCVSR if peaks_value_SCVSR != 0 else 0
features = [
mean, der_mean, neg_der_mean, neg_der_pro, local_min, avg_rising_time
] + power_0_24 + [zcr_SCSR, zcr_SCVSR, mean_peak_SCSR, mean_peak_SCVSR]
return features
def PPsubroutine(C, C2, C3, b, angdistancem, angdistancep, vmax, speedlim, predec, succ, N, M, index):
# C, C2, C3 are constants in the penalization function
# angdistancem = $\delta_{c^-c}$
# angdistancep = $\delta_{cc^+}$
# vmax = maximum leaf speed
# speedlim = s
# predec = predecesor index, either an index or an empty list
# succ = succesor index, either an index or an empty list
# lcm = vector of left limits in the previous aperture
# lcp = vector of left limits in the next aperture
# rcm = vector of right limits in the previous aperture
# rcp = vector of right limits in the previous aperture
# N = Number of beamlets per row
# M = Number of rows in an aperture
# index = index location in the set of apertures that I have saved.
posBeginningOfRow = 0
D = Dlist[index]
# vmaxm and vmaxp describe the speeds that are possible for the leaves from the predecessor and to the successor
vmaxm = vmax
vmaxp = vmax
# Arranging the predecessors and the succesors.
#Predecessor left and right indices
if type(predec) is list:
lcm = [0] * M
rcm = [N] * M
# If there is no predecessor is as if the pred. speed was infinite
vmaxm = float("inf")
else:
lcm = data.llist[predec]
rcm = data.rlist[predec]
#Succesors left and right indices
if type(succ) is list:
lcp = [0] * M
rcp = [N] * M
# If there is no successor is as if the succ. speed was infinite.
vmaxp = float("inf")
else:
lcp = data.llist[succ]
rcp = data.rlist[succ]
# Find geographical location of the first row.
geolocX = data.xinter[0]
# Find all possible locations of beamlets in this row according to geographical location
indys = np.where(geolocX == data.xdirection[index])
ys = data.ydirection[index][indys]
validbeamlets = np.in1d(data.yinter, ys)
validbeamlets = np.array(range(0, len(data.yinter)))[validbeamlets]
# Keep the location of the most leaf
leftmostleaf = len(ys) # Position in python position(-1) of the leftmost leaf
nodesinpreviouslevel = 0
oldflag = nodesinpreviouslevel
# First handle the calculations for the first row
beamGrad = D * data.voxelgradient
nodesinpreviouslevel = 0
posBeginningOfRow = 0
thisnode = 0
# Max beamlets per row
bpr = 50
networkNodesNumber = bpr * bpr + M * bpr * bpr + bpr * bpr # An overestimate of the network nodes in this network
# Initialization of network vectors. This used to be a list before
lnetwork = np.zeros(networkNodesNumber, dtype = np.int) #left limit vector
rnetwork = np.zeros(networkNodesNumber, dtype = np.int) #right limit vector
mnetwork = np.ones(networkNodesNumber, dtype = np.int) #Only to save some time in the first loop
wnetwork = np.zeros(networkNodesNumber, dtype = np.float) # Weight Vector
dadnetwork = np.zeros(networkNodesNumber, dtype = np.int) # Dad Vector. Where Dad is the combination of (l,r) in previous row
# Work on the first row perimeter and area values
for l in range(math.ceil(max(min(validbeamlets) - 1, lcm[0] - vmaxm * angdistancem/speedlim, lcp[0] - vmaxp * angdistancep / speedlim)), math.floor(min(max(validbeamlets), lcm[0] + vmaxm * angdistancem / speedlim, lcp[0] + vmaxp * angdistancep / speedlim))):
for r in range(math.ceil(max(l + 1, rcm[0] - vmaxm * angdistancem/speedlim, rcp[0] - vmaxp * angdistancep / speedlim)), math.floor(min(max(validbeamlets)+1, rcm[0] + vmaxm * angdistancem / speedlim, rcp[0] + vmaxp * angdistancep / speedlim))):
thisnode = thisnode + 1
nodesinpreviouslevel = nodesinpreviouslevel + 1
# First I have to make sure to add the beamlets that I am interested in
if(l + 1 <= r -1): # prints r numbers starting from l + 1. So range(3,4) = 3
# Dose = -sum( D[[i for i in range(l+1, r)],:] * data.voxelgradient)
Dose = -beamGrad[l+1:r].sum()
weight = C * ( C2 * (r - l) - C3 * b * (r - l)) - Dose
else:
weight = 0.0
# Create node (1,l,r) in array of existing nodes and update the counter
# Replace the following expression
# networkNodes.append([1, l, r, weight, 0])
lnetwork[thisnode] = l
rnetwork[thisnode] = r
wnetwork[thisnode] = weight
# dadnetwork and mnetwork don't need to be changed here for obvious reasons
posBeginningOfRow = posBeginningOfRow + nodesinpreviouslevel
mystart = time.time()
# Then handle the calculations for the m rows. Nodes that are neither source nor sink.
for m in range(2,M):
# Show time taken per row
myend = time.time()
mystart = myend
# Find geographical location of this row.
geolocX = data.xinter[m-1]
# Find all possible locations of beamlets in this row according to geography
indys = np.where(geolocX == data.xdirection[index])
ys = data.ydirection[index][indys]
validbeamlets = np.in1d(data.yinter, ys)
validbeamlets = np.array(range(0, len(data.yinter)))[validbeamlets]
oldflag = nodesinpreviouslevel
nodesinpreviouslevel = 0
# And now process normally checking against valid beamlets
for l in range(math.ceil(max(min(validbeamlets)-1, lcm[m] - vmaxm * angdistancem/speedlim, lcp[m] - vmaxp * angdistancep / speedlim)), math.floor(min(max(validbeamlets), lcm[m] + vmaxm * angdistancem / speedlim, lcp[m] + vmaxp * angdistancep / speedlim))):
for r in range(math.ceil(max(l + 1, rcm[m] - vmaxm * angdistancem/speedlim, rcp[m] - vmaxp * angdistancep / speedlim)), math.floor(min(max(validbeamlets) + 1, rcm[m] + vmaxm * angdistancem / speedlim, rcp[m] + vmaxp * angdistancep / speedlim))):
nodesinpreviouslevel = nodesinpreviouslevel + 1
thisnode = thisnode + 1
# Create node (m, l, r) and update the level counter
# networkNodes.append([m, l, r, float("inf"), float("inf")])
lnetwork[thisnode] = l
rnetwork[thisnode] = r
mnetwork[thisnode] = m
wnetwork[thisnode] = np.inf
lmlimit = leftmostleaf
rmlimit = (r - l) + leftmostleaf
if(lmlimit + 1 <= rmlimit - 1):
#Dose = - sum(D[[i for i in range(lmlimit + 1, rmlimit)],:] * data.voxelgradient)
Dose = -beamGrad[lmlimit+1:rmlimit].sum()
C3simplifier = C3 * b * (r - l)
else:
Dose = 0.0
C3simplifier = 0
lambdaletter = np.absolute(lnetwork[(posBeginningOfRow - oldflag): posBeginningOfRow] - l) + np.absolute(rnetwork[(posBeginningOfRow - oldflag): posBeginningOfRow] - r) - 2 * np.maximum(0, lnetwork[(posBeginningOfRow - oldflag): posBeginningOfRow] - r) - 2 * np.maximum(0, l - np.absolute(rnetwork[(posBeginningOfRow - oldflag): posBeginningOfRow]))
weight = C * (C2 * lambdaletter - C3simplifier) - Dose
# Add the weights that were just calculated
newweights = wnetwork[(posBeginningOfRow - oldflag): posBeginningOfRow] + weight
# Find the minimum and its position in the vector.
minloc = np.argmin(newweights)
wnetwork[thisnode] = newweights[minloc]
dadnetwork[thisnode] = minloc + posBeginningOfRow - oldflag
posBeginningOfRow = nodesinpreviouslevel + posBeginningOfRow # This is the total number of network nodes
# Keep the location of the leftmost leaf
leftmostleaf = len(ys) + leftmostleaf
thisnode = thisnode + 1
for mynode in (range(posBeginningOfRow - nodesinpreviouslevel, posBeginningOfRow)):
weight = C * ( C2 * (rnetwork[mynode] - lnetwork[mynode] ))
if(wnetwork[mynode] + weight <= wnetwork[thisnode]):
wnetwork[thisnode] = wnetwork[mynode] + weight
dadnetwork[thisnode] = mynode
p = wnetwork[thisnode]
thenode = thisnode # WILMER take a look at this
l = []
r = []
while(1):
# Find the predecessor data
l.append(lnetwork[thenode])
r.append(rnetwork[thenode])
thenode = dadnetwork[thenode]
if(0 == thenode): # If at the origin then break
break
l.reverse()
r.reverse()
return(p, l, r)
def rewardTF(t, direct, directHead, dOut, offset, offsetHead, angle_writer,
angle_sub, body_angle_writer, body_angle_sub, radHead,
lastTerm_writer, lastTerm_sub, model_states, PerformanceRecorder,
terminator):
arraySize = 625 # 4*500
arrayBody = 625 # 4*500
deltaAngleReward = 0.
angleAbort = 35.
deltaAngleRewardH = 0.
angleAbortH = 40.
import nest
import Variables as VAR
from vc import vec
import tf
import math
if lastTerm_sub.value is None:
lastTerm_writer.send_message(std_msgs.msg.Float64(0.0))
if angle_sub.value is None or body_angle_sub.value is None:
angle_writer.send_message(
std_msgs.msg.Float32MultiArray(data=[0.
for i in range(arraySize)]))
body_angle_writer.send_message(
std_msgs.msg.Float32MultiArray(data=[0.
for i in range(arrayBody)]))
# angle_writer.send_message(std_msgs.msg.Float32MultiArray([0.0 in range(arraySize)]))
return
if model_states.value is None or len(
model_states.value.pose) < 2 or radHead.value is None:
return
radHead = radHead.value.data
model_states = model_states.value
robot = model_states.pose[0]
rp = robot.position
ro = robot.orientation
ball = model_states.pose[1]
bp = ball.position
qRobot = list(
tf.transformations.quaternion_inverse([ro.x, ro.y, ro.z, ro.w]))
qRobotConj = tf.transformations.quaternion_conjugate(qRobot)
T0R = [[1, 0, 0, -rp.x], [0, 1, 0, -rp.y], [0, 0, 1, -rp.z], [0, 0, 0, 1]]
nppBallTrans = list(np.dot(T0R, [bp.x, bp.y, bp.z, 1]))
npBall = tf.transformations.quaternion_multiply(
tf.transformations.quaternion_multiply(qRobot, nppBallTrans),
qRobotConj)
xAxies = vec(1, 0)
npBall2d = vec(npBall[0], npBall[1])
angle = xAxies.findClockwiseAngle180(npBall2d)
angleRaw = angle
oH = 0.
if directHead.value is not None:
oH = directHead.value.data
bodyAngleRaw = angleRaw + oH * 90. # + (radHead * 180 / np.pi)
temp = list(angle_sub.value.data)
temp[int(math.floor((t * 50) % arraySize))] = angleRaw
tempBody = list(body_angle_sub.value.data)
# meanBodyAngleBefore = reduce(lambda a, b: a + b, tempBody) / len(tempBody)
tempBody[int(math.floor((t * 50) % arrayBody))] = bodyAngleRaw
angle_writer.send_message(std_msgs.msg.Float32MultiArray(data=temp))
body_angle_writer.send_message(
std_msgs.msg.Float32MultiArray(data=tempBody))
meanAngle = reduce(lambda a, b: a + b, temp) / len(temp)
meanBodyAngle = reduce(lambda a, b: a + b, tempBody) / len(tempBody)
# angleTrust = 0.0
# bodyAngleTrust = 0.0
# angle = angleTrust * angleRaw + (1 - angleTrust) * meanAngle
# bodyAngle = bodyAngleTrust * bodyAngleRaw + (1 - bodyAngleTrust) * meanBodyAngle
l = nrp.config.brain_root.conn_l
r = nrp.config.brain_root.conn_r
lH = nrp.config.brain_root.conn_lH
rH = nrp.config.brain_root.conn_rH
if t % 1 < 0.02:
distanceRB = np.sqrt(nppBallTrans[0]**2 + nppBallTrans[1]**2)
direction = 0.
directionHead = 0.
if direct.value:
direction = direct.value.data
if directHead.value:
directHead = directHead.value.data
PerformanceRecorder.record_entry(t, direction, directHead, meanAngle,
meanBodyAngle, angleRaw, bodyAngleRaw,
distanceRB)
# if VAR.ENBLE_LOGGING and t % 3 < 0.02:
# clientLogger.info("----------------Reward Function----------------")
# clientLogger.info('Current Angle:', angle)
# clientLogger.info('Current Distance: ', distanceRB)
# angle_writer.send_message(std_msgs.msg.Float64(0.))
# if(np.absolute(angle) > 50):
# clientLogger.info("angle to big! (>50)")
# clientLogger.info(angleBody)
if t < lastTerm_sub.value.data + 0.2:
angle_writer.send_message(
std_msgs.msg.Float32MultiArray(data=[0.
for i in range(arraySize)]))
body_angle_writer.send_message(
std_msgs.msg.Float32MultiArray(data=[0.
for i in range(arrayBody)]))
angle = 0.
bodyAngleRaw = 0.
# bodyAngle = 0.
# if t % 200 < 0.02:
# lastTerm_writer.send_message(std_msgs.msg.Float64(t-3))
# -----------------------------------------------------------------------BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
# ---------- Reward Setting for Body
judgedAngle = bodyAngleRaw
# if t < lastTerm_sub.value.data + 10.5:
# judgedAngle = meanAngle
if (np.absolute(meanBodyAngle) > angleAbort):
if (t > lastTerm_sub.value.data + 6.):
angle_writer.send_message(
std_msgs.msg.Float32MultiArray(
data=[0. for i in range(arraySize)]))
body_angle_writer.send_message(
std_msgs.msg.Float32MultiArray(
data=[0. for i in range(arrayBody)]))
dOut.send_message(0.)
offset.send_message(0.)
offsetHead.send_message(0.)
lastTerm_writer.send_message(std_msgs.msg.Float64(t))
terminator.send_message(std_msgs.msg.Bool(True))
return
hiddenLayer = nrp.config.brain_root.hidden_layer
# hiddenLayer_left = nrp.config.brain_root.hidden_layer_left
# hiddenLayer_right = nrp.config.brain_root.hidden_layer_right
# or (t < lastTerm_sub.value.data + 12.5):
if (np.absolute(judgedAngle) < deltaAngleReward):
nest.SetStatus(l, {"n": 0.})
nest.SetStatus(r, {"n": 0.})
# nest.SetStatus(l, {"c": 0.})
# nest.SetStatus(r, {"c": 0.})
for j in hiddenLayer:
# outConnections = nest.GetConnections(source=[j])
# weights = nest.GetStatus(outConnections, keys="weight")
reward = 0.
inCon = nest.GetConnections(target=[j])
# nest.SetStatus(inCon, {"c": 0.})
nest.SetStatus(inCon, {"n": reward})
# ----------------------------------
# ---------- Reward Setting 50r Head
judgedAngleH = angleRaw
if (np.absolute(judgedAngleH) > angleAbortH):
if (t > lastTerm_sub.value.data + 2.5):
angle_writer.send_message(
std_msgs.msg.Float32MultiArray(
data=[0. for i in range(arraySize)]))
body_angle_writer.send_message(
std_msgs.msg.Float32MultiArray(
data=[0. for i in range(arrayBody)]))
dOut.send_message(0.)
offset.send_message(0.)
offsetHead.send_message(0.)
lastTerm_writer.send_message(std_msgs.msg.Float64(t))
terminator.send_message(std_msgs.msg.Bool(True))
return
if (np.absolute(judgedAngleH) < deltaAngleRewardH
or t < lastTerm_sub.value.data + 0.4):
nest.SetStatus(lH, {"n": 0.})
nest.SetStatus(rH, {"n": 0.})
