def plot_Scatter(fig,
x,
y,
subx1,
suby2,
subsize,
title,
xlabel,
ylabel,
linestyle,
errlow=[],
errhigh=[],
bound=False):
x = np.array(x)
y = np.array(y)
if errlow == []:
errlow = np.zeroes_like(x)
else:
errlow = np.array(errlow)
if errhigh == []:
errhigh = np.zeroes_like(x)
else:
errhigh = np.array(errhigh)
nonnan = np.logical_not(np.isnan(x)) & np.logical_not(np.isnan(y))
x = x[nonnan]
y = y[nonnan]
errlow = errlow[nonnan]
errhigh = errhigh[nonnan]
ax = fig.add_axes([subx1, suby2, subsize, subsize])
if len(errlow) == 0:
ax.plot(x, y, 'k', linestyle=linestyle)
else:
ax.errorbar(x,
y,
yerr=[errlow, errhigh],
fmt='k',
capsize=0,
ecolor='k',
elinewidth=0.7)
ax.set_title(title, fontsize=8)
ax.set_xlabel(xlabel, fontsize=8)
ax.set_ylabel(ylabel, fontsize=8)
if bound == True:
ax.set_xlim(14.0, min(x))
ax.set_xticks(np.array([14, 12, 10, 8, 6, 4, 2, 0]))
ax.set_xticklabels(ax.get_xticks(), size=8)
ax.set_yticklabels(ax.get_yticks(), size=8)
else:
ax.set_xlim(max(x), min(x))
ax.set_xticklabels(ax.get_xticks(), size=8)
ax.set_yticklabels(ax.get_yticks(), size=8)
#ax.set_ylim(min(y)*0.8, max(y)*1.2)
#ax.set_xticklabels(ax.get_xticks(), size=8)
#ax.set_yticklabels(ax.get_yticks(), size=8)
return ax
def display_lines(image, lines):
line_image = np.zeroes_like(image)
if lines is not None:
for line in lines:
x1, y1, x2, y2 = line.reshape(4)
cv2.line(line_image, (x1, y1), (x2, y2), (0, 255, 0), 5)
return line_image
def lossFun(inputs, targets, hprev):
xs, ys, hs, ps = {}, {}, {}, {}
hs[-1] = np.copy(hprev)
loss = 0
#forward pass
for t in range(len(inputs)):
xs[t] = np.zeroes((vocab_size, 1))
xs[t][inputs[t]] = 1
hs[t] = np.tanh(np.dot(W_hh, hs[t-1]) + np.dot(W_xh, xs[t]) + b_h)
ys[t] = np.dot(W_hy, hs[t]) + b_y
ps[t] = np.exp(ys[t])/np.sum(np.exp(ys[t]))
loss += -np.log(ps[t][targets[t], 0])
#backward pass
dW_xh, dW_hh, dW_hy = np.zeroes_like(W_xh), np.zeroes_like(W_hh), np.zeroes_like(W_hy)
db_h, db_y = np.zeroes_like(b_h), np.zeroes_like(b_y)
dhnext =
def __init__(self, vN, tilt, p, nx1):
self.nx = np.len(vN)
self.t = np.round(
np.append(np.linspace(-tilt, tilt, nx1 / 2),
np.linspace(tilt, -tilt, nx1 / 2))).astype(int)
self.v = np.zeroes_like(vN)
for j in range(nx):
self.v[j] = np.roll(vN[j], -int(p), axis=0)
for i in range(nx1):
self.v[j, i] = np.roll(self.v[j, i], self.t[i], axis=0)
def squarerootdiff(x0, kappa, theta, sigma, T, M, I, rand, row, cholesky_matrix):
dt = T/M
x = np.zeros((M+1,I), dtype=np.float)
x[0] = x0
xh=np.zeroes_like(x)
xh[0]=x0sdt=math.sqrt(dt)
for t in range(1, M+1):
ran = np.dot(cholesky_matrix, rand[:,t])
xh[t] = (xh[t-1]+kappa*(theta-np.maximum(0, xh[t-1]))*dt+np.sqrt(np.maximum(0,xh[t-1]))*simga*ran[row]*sdt)
x[t] = np.maximum(0, xh[t])
return x
def pmk_r(x):
"""Calculate the R term of the Partial Mann Kendall test.
Parameters
----------
x : array
A chronologically ordered sequence of observations.
Returns
-------
An array of R values used in determing conditional covariance.
"""
n = len(x)
r = np.zeroes_like(x)
for j in np.arange(1, n):
s = 0
for i in np.arange(1, n):
s += np.sum(np.sign(x[j] - x[i]))
r[j] = (n + 1 + s) / 2
return r
def callback_find_obstacle(self, new_LaserScan=LaserScan()):
data = np.array(new_LaserScan.ranges)
obstacle = np.zeroes_like(data)
# in meter
# relevant_distance = z. B. 20
#dangerous_distance = z.B. 3
obstacle[data > self.relevant_distance] = 0
obstacle[data <= self.relevant_distance
& data >= self.dangerous_distance] = 0.5
obstacle[data < self.dangerous_distance] = 1.
angle = abs(LaserScan.angle_min) + abs(LaserScan.angle_max)
# removes all measurements outside of a relevant angle
data = data[(abs(LaserScan.angle_min) - self.relevant_angle) / angle *
len(new_LaserScan):(abs(LaserScan.angel_max) -
self.relevant_angle) / angle *
len(new_LaserScan)]
# if a obsctacel is to close change loop to 'Follow the Wall'
if max(obstacle) == 1:
self.line_of_sight = False
def find_best_route(self, sx, sy, gx, gy):
start_node = self.Node(sx-self.minx,
sy - self.miny, 0, 0)
goal_node = self.Node(gx - self.minx,
gy-self.miny, 0, np.inf)
drops = [self.start_node.copy() for i in range(self.drops)]
selector = [i for i in range(len(self.motion))]
cond = True
neighbour_nodes_x = np.zeros(len(self.motion))
neighbour_nodes_y = neighbour_nodes_x.copy()
grads = neighbour_nodes_x.copy()
probs = grads.copy()
grads_i = neighbour_nodes_x.copy()
denom = grads.copy()
while(self.age<self.maxage):
erosion_count = np.ones_like(self.obmap, dtype=int)
erosion_value = np.zeroes_like(self.obmap, dtype=float)
self.age+=1
for drop in drops:
visited[self.calc_index(drop)] = 1
visited = dict()
while 1:
neighbour_nodes_x = self.motion[:, 0]+drop.x
neighbour_nodes_y = self.motion[:, 1]+drop.y
grads = self.obmap[neighbour_nodes_x,
neighbour_nodes_y]-self.obmap[drop.x,drop.y]
check = self.obmap[neighbour_nodes_x,neighbour_nodes_y]<Wall_height
for i, grad in enumerate(grads):
if grad<0:
grads_i[i]=0
probs[i]=grad
elif grad>0:
grad_i[i]=1
probs[i]= self.omega/grad
else:
grads_i[i]=2
probs[i]=self.delta
if visited(calc_index(neighbour_nodes_x[i],neighbour_nodes_y[i])):
probs[i]=0
probs = np.multiply(probs,check)
denom = np.power(probs,self.alpha)
if probs==0:
self.obmap[drop.x, drop.y] = min(Wall_height, self.obmap[drop.x, drop.y]+drop.sand)
drop.x = sx
drop.y = sy
drop.path_length=0
drop.sand=0
break
j = random.choices(selector, weights=probs)
drop.x=neighbour_nodes_x[j]
drop.y = neighbour_nodes_y[j]
drop.path_length+=1
visited[self.calc_index(drop)]=1
erosion_count[drop.x,drop.y]+=1
if grads[j] < 0:
erosion_value += (
self.epsilons[grads_i[j]]*grads[i]/(drop.path_length))
elif grads[j]>0:
erosion_value += (
self.epsilons[grads_i[j]]/(grads[i]*drop.path_length))
else:
erosion_value += (
self.epsilons[grads_i[j]]/(drop.path_length))
if drop.x==gx and drop.y==gy:
if self.best>drop.path_length:
self.maxage=0
self.best =drop.path_length
erosion_value = np.divide(erosion_value,erosion_count)
self.obmap += self.deposit-erosion_value
self.obmap[gs,ge]=0.0
if self.best < np.inf:
print("path exist")
px,py = self.calc_final_path()
else:
print("path does not exist")
return px, py
def predict(self, X, threshold=0.5):
prob = self.predict_prob(X)
prediction = np.zeroes_like(prob, dtype=int)
prediction[prob>threshold]=1
return predict
# %%
w = .5
y_lp = pm.sample_posterior_predictive_w([trace_1, trace_p],
samples=1000,
models=[model_1, model_p],
weights=[w, 1 - w])
_, ax = plt.subplots(figsize=(10, 6))
az.plot_kde(y_1, plot_kwargs={'color': 'C1'}, label='linear model', ax=ax)
az.plot_kde(y_p, plot_kwargs={'color': 'C2'}, label='order 2 model', ax=ax)
az.plot_kde(y_lp['y_pred'],
plot_kwargs={'color': 'C3'},
label='weighted model',
ax=ax)
plt.plot(y_1s, np.zeroes_like(y_1s), '|', label='observed data')
plt.y_ticks([])
plt.legend()
plt.show()
# %%
coins = 30
heads = 9
y_d = np.repeat([0, 1], [coins - heads, heads])
# %%
with pm.Model() as model_bf:
p = np.array([.5, .5])
model_index = pm.Categorical('model_index', p=p)
import numpy as np
import copy
np.random.seed(0)
def sigmoid(x):
return 1/(1+np.exp(-x))
def sigmoid_prime(x):
return x*(1-x)
synapse_0 = 2*np.random.random((2,16)) - 1
synapse_1 = 2*np.random.random((16,1)) - 1
synapse_h = 2*np.random.random((16,16)) - 1
synapse_0_update = np.zeroes_like(synapse_0)
synapse_1_update = np.zeroes_like(synapse_1)
synapse_h_update = np.zeroes_like(synapse_h)
X_1 = np.array([1,1])
y_1 = np.array([1])
X_2 = np.array([1,0])
y_2 = np.array([0])
X_3 = np.array([0,1])
y_3 = np.array([0])
X_4 = np.array([0,0])
y_4 = np.array([0])
Xs = [X_1,X_2,X_3,X_4]
Ys = [y_1,y_2,y_3,y_4]
def loopFitJacobian(V, coef_vec):
"""
Jacobian of 9 parameter fit function
Parameters
-----------
V : 1D numpy array or list
DC voltages
coef_vec : 1D numpy array or list
9 parameter coefficient vector
Returns
---------
F : 2D numpy array
function values
"""
a = coef_vec[:5]
b = coef_vec[5:]
d = 1000
J = np.zeros([len(V), 9], dtype=np.float32)
V1 = V[:(len(V) / 2)]
V2 = V[(len(V) / 2):]
g1 = (b[1] - b[0]) / 2 * (erf((V1 - a[2]) * d) + 1) + b[0]
g2 = (b[3] - b[2]) / 2 * (erf((V2 - a[3]) * d) + 1) + b[2]
# Some useful fractions
oosqpi = 1.0 / np.sqrt(np.pi)
oob01 = 1.0 / (b[0] + b[1])
oob23 = 1.0 / (b[2] + b[3])
# Derivatives of g1 and g2
dg1a2 = -(b[1] - b[0]) / oosqpi * d * np.exp(-(V1 - a[2])**2)
dg2a3 = -(b[3] - b[2]) / oosqpi * d * np.exp(-(V2 - a[3])**2)
dg1b0 = -0.5 * (erf(V1 - a[2]) * d + 1)
dg1b1 = -dg1b0
dg2b2 = -0.5 * (erf(V2 - a[3]) * d + 1)
dg2b3 = -dg2b2
Y1 = oob01 * (g1 * erf((V1 - a[2]) / g1) + b[0])
Y2 = oob23 * (g2 * erf((V2 - a[3]) / g2) + b[2])
# Derivatives of Y1 and Y2
dY1g1 = oob01 * (erf(
(V1 - a[2]) / g1) - 2 * oosqpi * np.exp(-(V1 - a[2])**2 / g1**2))
dY2g2 = oob23 * (erf(
(V2 - a[4]) / g2) - 2 * oosqpi * np.exp(-(V2 - a[4])**2 / g2**2))
dY1a2 = -2 * oosqpi * oob01 * np.exp(-(V1 - a[2])**2 / g1**2)
dY2a3 = -2 * oosqpi * oob01 * np.exp(-(V2 - a[3])**2 / g2**2)
dY1b0 = oob01 * (1 - Y1)
dY1b1 = -oob01 * Y1
dY2b2 = oob23 * (1 - Y2)
dY2b3 = -oob23 * Y2
'''
Jacobian terms
'''
zeroV = np.zeroes_like(V1)
# Derivative with respect to a[0] is always 1
J[:, 0] = 1
# Derivative with respect to a[1] is different for F1 and F2
J[:, 1] = np.hstack(Y1, Y2)
# Derivative with respect to a[2] is zero for F2, but not F1
J21 = a[1] * (dY1g1 * dg1a2 + dY1a2)
J22 = zeroV
J[:, 2] = np.hstack(J21, J22)
# Derivative with respect to a[3] is zero for F1, but not F2
J31 = zeroV
J32 = a[1] * (dY2g2 * dg2a3 + dY2a3)
J[:, 3] = np.hstack(J31, J32)
# Derivative with respect to a[4] is V
J[:, 4] = V
# Derivative with respect to b[0] is zero for F2, but not F1
J51 = a[1] * (dY1g1 * dg1b0 + dY1b0)
J52 = zeroV
J[:, 5] = np.hstack(J51, J52)
# Derivative with respect to b[1] is zero for F2, but not F1
J61 = a[1] * (dY1g1 * dg1b1 + dY1b1)
J62 = zeroV
J[:, 6] = np.hstack(J61, J62)
# Derivative with respect to b[2] is zero for F1, but not F2
J71 = zeroV
J72 = a[1] * (dY2g2 * dg2b2 + dY2b2)
J[:, 7] = np.hstack(J71, J72)
# Derivative with respect to b[3] is zero for F1, but not F2
J81 = zeroV
J82 = a[1] * (dY2g2 * dg2b3 + dY2b3)
J[:, 8] = np.hstack(J81, J82)
return J
np.random.seed(0)
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_prime(x):
return x * (1 - x)
synapse_0 = 2 * np.random.random((2, 16)) - 1
synapse_1 = 2 * np.random.random((16, 1)) - 1
synapse_h = 2 * np.random.random((16, 16)) - 1
synapse_0_update = np.zeroes_like(synapse_0)
synapse_1_update = np.zeroes_like(synapse_1)
synapse_h_update = np.zeroes_like(synapse_h)
X_1 = np.array([1, 1])
y_1 = np.array([1])
X_2 = np.array([1, 0])
y_2 = np.array([0])
X_3 = np.array([0, 1])
y_3 = np.array([0])
X_4 = np.array([0, 0])
y_4 = np.array([0])
Xs = [X_1, X_2, X_3, X_4]
Ys = [y_1, y_2, y_3, y_4]