def up_and_out_calculator(S, t):
tau = time_to_maturity - t
nd = [np.nan
] + [norm.cdf(di(S, K, Su, r, sigma, tau)) for di in d_formula]
return S*(nd[1] - nd[3] - np.float_power(Su/S, 1+2*r/sigma/sigma)*(nd[6] - nd[8])) \
- K*np.exp(-r*tau)*(nd[2] - nd[4] - np.float_power(Su/S, -1 + 2*r/sigma/sigma)*(nd[5] - nd[7]))
def eval_wavefunction(self, x_array: iterable):
"""
Computes wave function, based on eigenfunctions psi_n(x) = A_n * H_n(alpha * x) * exp(-alpha^2 * x^2 / 2)
:parameter x_array: array containing points on the x-position axis
:returns dictionary of two arrays containing wavefunction's real and imaginary parts evaluated in x_array
key = 'real' : real part
key = 'imaginary': imaginary part
"""
# in general psi_tot will be a complex function
psi_tot = {
'real': np.zeros(len(x_array)),
'imaginary': np.zeros(len(x_array))
}
for n in self.n_coeffs.keys():
# compute factorial via np.math.factorial()
if n <= 16:
a_n = np.float_power(self.mass * self.omega / (np.pi * self.h_bar), 0.25) \
/ np.sqrt(2**n * np.math.factorial(n))
# compute factorial via Stirling Approximation
else:
a_n = np.float_power(self.mass * self.omega / (np.pi * self.h_bar), 0.25) \
/ (np.float_power(2 * np.pi * n, 0.25) * np.float_power(2 * n / np.e, n * 0.5))
hermite_n = special.eval_hermite(n, self.alpha * x_array)
psi_n = a_n * hermite_n * np.exp((-(self.alpha * x_array)**2 / 2))
# iteratively add real and imaginary parts of psi_tot
psi_tot['real'] += complex(self.n_coeffs[n]).real * psi_n
psi_tot['imaginary'] += complex(self.n_coeffs[n]).imag * psi_n
return psi_tot
def blend_img(background, overlay_rgba, gamma=0.2): # taken from VIR
alpha = overlay_rgba[:, :, 3]
over_corr = np.float_power(overlay_rgba[:, :, :3], gamma)
bg_corr = np.float_power(background, gamma)
return np.float_power(over_corr * alpha[..., None] +
(1 - alpha)[..., None] * bg_corr,
1 / gamma) # dark magic
def apply_symmetry(vn, sigma, eta_list):
vn_sym = np.full_like(vn, float('NaN'))
sigma_sym = np.full_like(sigma, float('NaN'))
for n in range(0, 3):
for c in range(0, 9):
for eta_bin in range(0, 34):
eta = eta_list[eta_bin]
if abs(eta) < 3.4:
neg_eta_bin = 27 - eta_bin
#print 1 / np.float_power(sigma[n, eta_bin, c], 2)
weights = [
1 / np.float_power(sigma[n, eta_bin, c], 2),
1 / np.float_power(sigma[n, neg_eta_bin, c], 2)
]
vn_sym[n, eta_bin,
c] = (weights[0] * vn[n, eta_bin, c] +
weights[1] * vn[n, neg_eta_bin, c]) / (
weights[0] + weights[1])
sigma_sym[n, eta_bin,
c] = 1 / np.sqrt(weights[0] + weights[1])
vn_sym[n, neg_eta_bin, c] = vn_sym[n, eta_bin, c]
sigma_sym[n, neg_eta_bin, c] = sigma_sym[n, eta_bin, c]
else:
vn_sym[n, eta_bin, c] = vn[n, eta_bin, c]
sigma_sym[n, eta_bin, c] = sigma[n, eta_bin, c]
return vn_sym, sigma_sym
def moveToPoint(current_x, current_y, current_angle,
desired_x, desired_y, kv, kh):
"""Implements a simple proportional controller for Move to Point
Parameters
----------
current_x : float
The current x position of the robot
current_y : float
The current y position of the robot
current_angle : float
The current heading angle of the robot
desired_x : float
The desired x position of the robot
desired_y : float
The desired y position of the robot
kv : float
The proportional gain for velocity
kh : float
The proportional gain for heading/steering angle, kh > 0.
Returns
----------
newV : float
The newly calculated velocity for the robot
newSteer : float
The newly calculated steering angle for the robot
"""
newV = kv * np.sqrt(np.float_power(desired_x - current_x, 2)
+ np.float_power(desired_y - current_y, 2))
desired_angle = np.arctan((desired_y - current_y) /
(desired_x - current_x))
newSteer = kh * angdiff(desired_angle, current_angle)
return newV, newSteer
def DoCV(X, fx, y, kernel, k=10): n = X.shape[0] if(kernel == rbf): hypers = np.float_power( 10, np.arange(-3, 4, .25) ) elif(kernel == poly): hypers = np.arange(1, 100, 2) #print(hypers) Ls = np.float_power( 10, np.arange(-10, 5, .25) ) results = [] for hyper in hypers: K = makeKernel(X, kernel, hyper = hyper) # leave one out cross validation K_trains, y_trains, K_vals, y_vals = kfold(K, y, k = k) for L in Ls: mses = [] for i in range(k): K_train = K_trains[i]; y_train = y_trains[i]; K_val = K_vals[i]; y_val = y_vals[i] #print(K_train.shape, y_train.shape, K_val.shape, y_val.shape) alpha = train(K_train, y_train, L=L) f = predict(K_val, alpha) mse = MSE(f, y_val) mses.append(mse) results.append( ( np.mean(mses), hyper, L ) ) best = np.inf; bestidx = 0 for idx, line in enumerate(results): if(line[0] < best): best = line[0] bestidx = idx mse, hyper, L = results[bestidx] print(mse, hyper, L) return(hyper, L)
def interval2ratio_np(intervals: np.ndarray) -> np.ndarray:
"""
Vectorized version of i2r
"""
out = intervals / 12.
np.float_power(2, out, out=out)
return out
def test_squared_emphasized_loss(self):
from model.loss import squared_emphasized_loss
alpha = 0.4
beta = 0.6
axis = 1
labels = np.array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [4.0, 5.0, 6.0]])
predictions = np.array([[0.0, 2.0, 3.0], [3.0, 1.0, 4.0],
[6.0, 4.0, 7.0]])
corrupted_inds = [0]
uncorrupted_inds = np.delete(np.arange(labels.shape[axis]),
corrupted_inds)
x_c = np.take(labels, corrupted_inds, axis)
z_c = np.take(predictions, corrupted_inds, axis)
x = np.take(labels, uncorrupted_inds, axis)
z = np.take(predictions, uncorrupted_inds, axis)
expected_output = alpha * np.float_power(
x_c - z_c, 2).sum() + beta * np.float_power(x - z, 2).sum()
labels = tf.convert_to_tensor(labels)
predictions = tf.convert_to_tensor(predictions)
loss = squared_emphasized_loss(labels,
predictions,
corrupted_inds,
axis=axis,
alpha=alpha,
beta=beta)
with tf.Session() as sess:
actual_output = sess.run(loss)
self.assertAlmostEqual(expected_output, actual_output, places=4)
def scale_at_time(self, time):
# This method takes an input time (in seconds) and gives an approximation of the scale factor at that time.
# Since no general a(t) is known, we break up the timeline into epochs of radiation, matter or cosmological
# constant domination and use approximations given in Introduction to Cosmology in the various sections of
# chapter 5
# First, I define the scale factors and times when radiation's density was equal to matter's, and when matter's
# was equal to the density of the cosmological constant
scale_rm = self.rad_density/self.matter_density
scale_ml = np.float_power(self.matter_density/self.lambda_density, 1.0/3.0)
time_rm = (4.0/3.0)*(1-1/np.sqrt(2)) * np.power(scale_rm, 2)/np.sqrt(self.rad_density) \
* Conversions.kilometers_in_mpc / self.hubble
time_ml = 2 / self.hubble * Conversions.kilometers_in_mpc / (3 * np.sqrt(1 - self.matter_density))\
* np.log(1 + np.sqrt(2))
# Here are the various epochs. Some fudging was done to attempt smoother transitions
if 0 < time < .75*time_rm:
# radiation and matter, with a < a_rm
return np.sqrt((2 * np.sqrt(self.rad_density) * time * self.hubble / Conversions.kilometers_in_mpc))
elif .75*time_rm <= time < 1.25*time_ml:
# radiation and matter, with a > a_rm
return np.float_power(time * (3.0 / 2.0) * np.sqrt(self.matter_density) * self.hubble
/ Conversions.kilometers_in_mpc, 2.0 / 3.0)
elif time >= 1.25*time_ml:
# matter and lambda, with a > a_ml
return scale_ml*np.exp(np.sqrt(1-self.matter_density) * time * self.hubble /
Conversions.kilometers_in_mpc / 2.975) # 2.975 is another fudge factor
# to ensure the scale factor at
# 13.75 Gyr is 1
else:
print("Time must be greater than 0!")
return 0
def qffl_aggregation_centered(OnlineClients, Server, online_clients, lr):
"""Aggregate gradients for federated learning.
Each local model first gets the difference between current model and
previous synchronized model, and then all-reduce these difference by SUM.
"""
Server.optimizer.zero_grad()
num_online_clients = len(online_clients)
h = 0.0
for o in online_clients:
for i, (server_param, client_param) in enumerate(zip(Server.model.parameters(), OnlineClients[o].model.parameters())):
# get model difference.
param_diff = (server_param.data - client_param.data) * \
( np.float_power(OnlineClients[o].full_loss + 1e-10, Server.args.qffl_q) / lr )
server_param.grad.data.add_(param_diff)
h += Server.args.qffl_q * np.float_power(OnlineClients[o].full_loss + 1e-10, Server.args.qffl_q-1.0) * \
param_diff.norm().pow(2).item()
h += np.float_power(OnlineClients[o].full_loss + 1e-10, Server.args.qffl_q) / lr
for server_param in Server.model.parameters():
server_param.grad.data.div_(h+1e-10)
Server.optimizer.step(
apply_lr=False,
scale=Server.args.lr_scale_at_sync,
apply_in_momentum=False,
apply_out_momentum=Server.args.out_momentum,
)
return
def w(x, y, r=2, delta=0.1, nq=1000):
""" Delta-Trimmed r-Wasserstein distance between the empirical measures of two
one-dimensional samples.
Parameters
----------
x : np.ndarray (n,)
sample from P
y : np.ndarray (m,)
sample from Q
r : int, optional
order of the Wasserstein distance
delta : float, optional
trimming constant, between 0 and 0.5.
nq : int, optional
number of quantiles to use in Monte Carlo integral approximations
Returns
-------
W : float
delta-trimmed r-Wasserstein distance
"""
n = x.size
m = y.size
us = np.linspace(delta, 1 - delta, nq)
x_quant = aux._sample_quantile(x, us)
y_quant = aux._sample_quantile(y, us)
integ = np.mean(np.float_power(np.abs(x_quant - y_quant), r))
return np.float_power(((1 / (1 - 2 * delta)) * integ), 1 / r)
def get_feature_from_wordmap_SPM(wordmap, layer_num, dict_size):
'''
Compute histogram of visual words using spatial pyramid matching.
[input]
* wordmap: numpy.ndarray of shape (H,W)
* layer_num: number of spatial pyramid layers
* dict_size: dictionary size K
[output]
* hist_all: numpy.ndarray of shape (K*(4^layer_num-1)/3) (as given in the write-up)
'''
layers = np.arange(0, layer_num, 1)
hist_all = []
for l in layers:
if l == 0 or l == 1:
weight = np.float_power(2, (-layer_num))
else:
weight = np.float_power(2, (-l - (layer_num) - 1))
#declare the dimensions of the cell
dimension_of_cells = 2**l
#splitting the rows and columns in number of cells
rows = np.array_split(wordmap, dimension_of_cells, axis=1)
for i in rows:
columns = np.array_split(i, dimension_of_cells, axis=0)
for cell in columns:
hist = get_feature_from_wordmap(cell, dict_size)
hist = hist * weight
hist_all = np.append(hist_all, hist)
hist_all = hist_all / np.max(hist_all)
return hist_all
def computegaussian(self):
print("Computing gaussian curvature. Be patient...")
kernely = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]],
dtype=np.float32)
kernelx = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]],
dtype=np.float32)
h = self.pgrads.shape[0]
w = self.pgrads.shape[1]
self.gaussgrad = np.zeros((h, w, 1), dtype=np.float32)
Ixx = cv.filter2D(self.pgrads, cv.CV_32F, kernelx)
Ixy = cv.filter2D(self.pgrads, cv.CV_32F, kernely)
Iyy = cv.filter2D(self.qgrads, cv.CV_32F, kernely)
Iyx = cv.filter2D(self.qgrads, cv.CV_32F, kernelx)
self.gaussgrad = ((Ixx * Iyy) - Ixy * Iyx) / np.power(
(1 + np.float_power(self.pgrads, 2) +
np.float_power(self.qgrads, 2)), 2)
print("Gaussian curvature computation end.")
gaussgrad_norm = cv.normalize(self.gaussgrad, None, 0, 255,
cv.NORM_MINMAX, cv.CV_8U)
if self.display:
cv.imshow('gaussgrad', gaussgrad_norm)
cv.waitKey(0)
cv.destroyAllWindows()
return gaussgrad_norm
def _ll_hdlnegbin2(y, x1, x2, beta1, beta2, alpha):
"""
The function calculates the log likelihood function of the hurdle negative
binomial regression.
Parameters:
y : the frequency outcome
x1 : variables for the probability model in the hurdle negative binomial regression
x2 : variables for the count model in the hurdle negative binomial regression
beta1 : coefficients for the probability model in the hurdle negative binomial regression
beta2 : coefficients for the count model in the hurdle negative binomial regression
alpha : the dispersion parameter in the negative binomial distribution
"""
xb1 = numpy.dot(x1, beta1)
xb2 = numpy.dot(x2, beta2)
p0 = numpy.exp(xb1) / (1 + numpy.exp(xb1))
mu = numpy.exp(xb2)
i0 = numpy.where(y == 0, 1, 0)
a1 = 1 / alpha
pr = p0 * i0 + \
(1 - p0) / (1 - numpy.float_power(a1 / (a1 + mu), a1)) * \
scipy.special.gamma(y + a1) / (scipy.special.gamma(y + 1) * scipy.special.gamma(a1)) * \
numpy.float_power(a1 / (a1 + mu), a1) * numpy.float_power(mu / (a1 + mu), y) * (1 - i0)
ll = numpy.log(pr)
return (ll)
def channel_gain_type1(self, cluster):
n_group = len(cluster)
n_su = n_group * self.n_su_group_type1
SU_x = np.zeros(n_su)
SU_y = np.zeros(n_su)
for k in range(n_group):
group = cluster[k]
SU_x[k * self.n_su_group_type1: (k+1) * self.n_su_group_type1] = \
self.SU_x_type1[group][:]
SU_y[k * self.n_su_group_type1: (k+1) * self.n_su_group_type1] = \
self.SU_y_type1[group][:]
channel_gain = np.zeros((n_su, n_su))
for k1 in range(n_su):
for k2 in range(n_su):
d = np.sqrt(
np.float_power(SU_x[k1] - SU_x[k2], 2) +
np.float_power(SU_y[k1] - SU_y[k2], 2))
if (k1 == k2):
channel_gain[k1, k2] = 0
else:
channel_gain[k1, k2] = np.float_power(
10, -((46.4 + 35 * np.log10(d) +
20 * np.log10(self.fc / 5)) / 10))
return channel_gain
def computedepthmap(self):
h = self.normalmap.shape[0]
w = self.normalmap.shape[1]
P = np.zeros((h, w, 2), dtype=np.float32)
Q = np.zeros((h, w, 2), dtype=np.float32)
tempZ = np.zeros((h, w, 2), dtype=np.float32)
self.Z = np.zeros((h, w), dtype=np.float32)
landa = 1.0
mu = 1.0
cv.dft(self.pgrads, P, cv.DFT_COMPLEX_OUTPUT)
cv.dft(self.qgrads, Q, cv.DFT_COMPLEX_OUTPUT)
for i in range(1, h):
for j in range(1, w):
u = np.sin(i * 2 * np.pi / h)
v = np.sin(j * 2 * np.pi / w)
uv = np.float_power(u, 2) + np.float_power(v, 2)
d = (1 + landa) * uv + mu * np.float_power(uv, 2)
tempZ[i, j, 0] = (u * P[i, j, 1] + v * Q[i, j, 1]) / d
tempZ[i, j, 1] = (-u * P[i, j, 0] - v * Q[i, j, 0]) / d
tempZ[0, 0, 0] = 0
tempZ[0, 0, 1] = 0
flags = cv.DFT_INVERSE + cv.DFT_SCALE + cv.DFT_REAL_OUTPUT
cv.dft(tempZ, self.Z, flags)
z_norm = cv.normalize(self.Z, None, 0, 255, cv.NORM_MINMAX, cv.CV_8U)
if self.display:
cv.imshow('z_norm', z_norm)
cv.waitKey(0)
cv.destroyAllWindows()
return z_norm
def a_state(N, alpha):
unnormalised = np.array([
np.float_power(i + 1, -alpha) + np.float_power((N - i), -alpha)
for i in range(N)
])
norm = np.sqrt(np.inner(unnormalised, unnormalised))
return (1 / norm) * unnormalised
def residual_2D_ThomasFermiBEC(pars,x,y,data=None, eps=None):
"""
This is the Thormas-Fermi profile from eq. 44 from Making, Probing, Understanding
BEC by Ketterle et al.
residual_2D(pars,x,y,data=None, eps=None)
"""
parvals = pars.valuesdict() # a Parameters() object is passed as "pars"
max_density_cond = parvals["OD_cond_0"]
Thomas_Fermi_rad_x = parvals["x_TF_cond"]
Thomas_Fermi_rad_y = parvals["y_TF_cond"]
center_x_cond = parvals["x0_cond"]
center_y_cond = parvals["y0_cond"]
bgr = parvals["backgr"]
#NOTE! X corresponds to axis 1 (horizontal), Y corresponds to axis 0 (vertical)
model = max_density_cond*np.float_power(np.clip(0,1-np.float_power((x-center_x_cond)/Thomas_Fermi_rad_x,2.)-\
np.float_power((y-center_y_cond)/Thomas_Fermi_rad_y,2.),None),1.5) + bgr
if data is None:
return np.array(model) # we don't flatten here because this is for plotting
if eps is None:
resid = np.array(model - data)
#print(resid.flatten())
return resid.flatten() # minimization array must be flattened (LMFIT FAQ)
else:
resid = np.array((model - data)/eps)
return resid.flatten()
def getlowerbound(est_mean, t, Nt):
delta = np.float_power(10, -8)
eps = np.float_power(10, -5)
u = est_mean
if (u > 0.0):
if (u >= 1 - delta):
u = 1 - delta
q = u - delta
for i in range(0, 2000):
f = np.log(
(4 * e + 4) * arms * np.float_power(t, 2) / delt) + np.log(
np.log((4 * e + 4) * arms * np.float_power(t, 2) /
delt)) - kl_div(u, q) * Nt
df = -1 * Nt * (q - u) / (q * (1.0 - q))
q = np.maximum(((0 + delta)),
np.minimum(((q - f / df)), ((u - delta))))
if (f * f < eps):
break
return q
else:
if u == 0:
return 0
def generative_likelihood_probability(digits, means, covariances):
'''
digits: n x 64 | 10 comes from the set of labels
Compute the generative log-likelihood:
log p(x|y,mu,Sigma)
Should return an n x 10 numpy array in terms of probability
'''
# for storing digit likelihood 0 - 9
likelihood_set = []
n = digits.shape[0]
for i in range(10):
cov_inv = np.linalg.inv(covariances[i])
det = np.linalg.det(covariances[i])
# shape of (n, 64)
digits_diff = digits - means[i]
# n is number of digits
n_by_n_matrix = np.dot(np.dot(digits_diff, cov_inv),
np.transpose(digits_diff))
# shape (n,)
n_by_one_tmp = np.diag(n_by_n_matrix)
n_by_one = n_by_one_tmp.reshape(n, 1)
# d is 64!! # of x dimension!!!
term_1 = np.float_power(2 * np.pi, -64 / 2)
term_2 = np.float_power(det, -0.5)
term_3 = np.exp(-0.5 * n_by_one)
p_i = term_1 * term_2 * term_3
likelihood_set.append(p_i)
all_concat = np.concatenate(likelihood_set, axis=1)
# should be shape of nx10
print("generative_likelihood_probability shape: ", all_concat.shape)
return all_concat
def train(self):
print('Training with {} workers ---'.format(self.clients_per_round))
num_clients = len(self.clients)
pk = np.ones(num_clients) * 1.0 / num_clients
batches = {}
for c in self.clients:
batches[c] = gen_epoch(c.train_data, self.num_rounds+2)
print('Have generated training batches for all clients...')
for i in trange(self.num_rounds+1, desc='Round: ', ncols=120):
# test model
if i % self.eval_every == 0:
num_test, num_correct_test = self.test() # have set the latest model for all clients
num_train, num_correct_train = self.train_error()
num_val, num_correct_val = self.validate()
tqdm.write('At round {} testing accuracy: {}'.format(i, np.sum(np.array(num_correct_test)) * 1.0 / np.sum(np.array(num_test))))
tqdm.write('At round {} training accuracy: {}'.format(i, np.sum(np.array(num_correct_train)) * 1.0 / np.sum(np.array(num_train))))
tqdm.write('At round {} validating accuracy: {}'.format(i, np.sum(np.array(num_correct_val)) * 1.0 / np.sum(np.array(num_val))))
if self.track_individual_accuracy==1:
test_accuracies = np.divide(np.array(num_correct_test), np.array(num_test))
for idx in range(len(self.clients)):
tqdm.write('Client {} testing accuracy: {}'.format(self.clients[idx].id, test_accuracies[idx]))
if i % self.log_interval == 0 and i > int(self.num_rounds/2):
test_accuracies = np.divide(np.asarray(num_correct_test), np.asarray(num_test))
np.savetxt(self.output + "_" + str(i) + "_test.csv", test_accuracies, delimiter=",")
train_accuracies = np.divide(np.asarray(num_correct_train), np.asarray(num_train))
np.savetxt(self.output + "_" + str(i) + "_train.csv", train_accuracies, delimiter=",")
validation_accuracies = np.divide(np.asarray(num_correct_val), np.asarray(num_val))
np.savetxt(self.output + "_" + str(i) + "_validation.csv", validation_accuracies, delimiter=",")
indices, selected_clients = self.select_clients(round=i, pk=pk, num_clients=self.clients_per_round)
Deltas = []
hs = []
selected_clients = selected_clients.tolist()
selected_clients_grads = []
for c in selected_clients:
# communicate the latest model
c.set_params(self.latest_model)
weights_before = c.get_params()
# solve minimization locally
batch = next(batches[c])
_, grads, loss = c.solve_sgd(batch)
Deltas.append([np.float_power(loss+1e-10, self.q) * grad for grad in grads[1]])
if self.static_step_size:
hs.append(1.0/self.learning_rate)
else:
hs.append(self.q * np.float_power(loss+1e-10, (self.q-1)) * norm_grad(grads[1]) + (1.0/self.learning_rate) * np.float_power(loss+1e-10, self.q))
self.latest_model = self.aggregate2(weights_before, Deltas, hs)
def computemedian(self):
print("Computing median curvature. Be patient...")
h = self.pgrads.shape[0]
w = self.pgrads.shape[1]
self.meangrad = np.zeros((h, w, 1), dtype=np.float32)
scale = 1
delta = 0
ddepth = cv.CV_32F
Ixx = cv.Sobel(self.pgrads,
ddepth,
1,
0,
ksize=1,
scale=scale,
delta=delta,
borderType=cv.BORDER_DEFAULT)
Ixy = cv.Sobel(self.pgrads,
ddepth,
0,
1,
ksize=1,
scale=scale,
delta=delta,
borderType=cv.BORDER_DEFAULT)
Iyy = cv.Sobel(self.qgrads,
ddepth,
0,
1,
ksize=1,
scale=scale,
delta=delta,
borderType=cv.BORDER_DEFAULT)
Iyx = cv.Sobel(self.qgrads,
ddepth,
1,
0,
ksize=1,
scale=scale,
delta=delta,
borderType=cv.BORDER_DEFAULT)
a = (1 + np.float_power(self.pgrads, 2)) * Iyy
b = self.pgrads * self.qgrads * (Ixy + Iyx)
c = (1 + np.float_power(self.qgrads, 2)) * Ixx
d = np.float_power(
1 + np.float_power(self.pgrads, 2) +
np.float_power(self.qgrads, 2), 3 / 2)
self.meangrad = (a - b + c) / d
print("Median curvature computation end.")
meangrad_norm = cv.normalize(self.meangrad, None, 0, 255,
cv.NORM_MINMAX, cv.CV_8U)
if self.display:
cv.imshow('meangrad', meangrad_norm)
cv.waitKey(0)
cv.destroyAllWindows()
return meangrad_norm
def _np_log_integrate_1x(x, b):
with np.errstate(invalid='ignore'):
choices = [
np.log(np.log(x)),
np.log1p(-np.float_power(x, -b)) - np.log(b),
np.log((1 - np.float_power(x, -b)) / b)
]
return np.select([b == 0, b > 0, b < 0], choices, np.nan)
def get_polynomial(X, degree): X_poly = [] X1 = [x[1] for x in X] X2 = [x[2] for x in X] for i in range(0, degree+1): for j in range(i+1): X_poly.append( list( np.float_power( X1, (i-j) ) * np.float_power(X2, j) ) ) return np.transpose(X_poly)
def test_float_power_array(self):
assert np.all(
np.float_power(np.array([1., 2., 3.]) *
u.m, 3.) == np.array([1., 8., 27.]) * u.m**3)
# regression check on #1696
assert np.all(
np.float_power(np.arange(4.) * u.m, 0.) == 1. *
u.dimensionless_unscaled)
def select_param_rbf(X, y):
"""
Sweeps different settings for the hyperparameters of an rbf-kernel SVM,
calculating the k-fold CV performance for each setting on X, y. This function has some
preset variables that I describe right below ---v
NOTE: After researching SVMs and kernels, I found that the the rbf kernel
is the most flexible kernel and usually better-performing than others with multiclass
classification. The rbf kernel get even stronger with one-vs-one method of multiclass
classification, as compared to one-vs-all, when dealing multiple labels. Also, I found
out that f1_score is a good metric to use in this situation as well. And 5-fold cv takes
a while to run, so I'm going with 3-fold cv.
Input:
X: (n,d) array of feature vectors, where n is the number of examples
and d is the number of features
y: (n,) array of labels {1, 0, -1}
Returns:
The parameter value(s) for a quadratic-kernel SVM that maximize
the average 3-fold CV performance and the best performnce
"""
#our c and gamma ranges to test
C_range = np.float_power(np.repeat(np.float(10), 4),
range(-1, 3),
dtype=np.float64)
gamma_range = np.float_power(np.repeat(np.float(10), 3),
range(-2, 1),
dtype=np.float64)
#the best parameteres and their performance
best_params = (C_range[0], gamma_range[0])
best_perf = np.float64('-inf')
#labels for multiclass classification
labels = [-1, 0, 1]
#go through each c value
for c in C_range:
#go through each gamma value
for gamma in gamma_range:
#create our classifier with the according c and gamma values, test it's 3fold f1_score performance
clf = SVC(kernel='rbf',
C=c,
gamma=gamma,
decision_function_shape='ovo')
current_perf = cv_performance(clf,
X,
y,
k=3,
metric='f1_score',
labels=labels)
#save best performances accordingly
if (current_perf > best_perf):
best_params = (c, gamma)
best_perf = current_perf
return best_perf, best_params
def Semimajor(R_star, sinT_t, Depth, b):
"""
Input : Radius of the star, sin^2(T_t*pi/Period),
Depth (or Delta Flux), impact parameter b
"""
A = np.float_power((1 + np.sqrt(Depth)), 2)
a = R_star * np.sqrt(
abs(A - (1 - sinT_t) * np.float_power(b, 2)) / (sinT_t))
return a
def Impact_parameter(sinT_t, sinT_f, Depth):
"""
Input : sin^2(T_t*pi/Period), sin^2(T_f*pi/Period),
Depth
"""
A = np.float_power((1 + np.sqrt(Depth)), 2)
B = np.float_power((1 - np.sqrt(Depth)), 2)
b = np.sqrt(abs(B - sinT_f * A / sinT_t) / (1 - sinT_f / sinT_t))
return b
def predict_inst(self, entry, return_probs):
prob_0 = np.log10(self.cls_priors[0]) + entry.dot(np.log10(self.cond_probs[0]))
prob_1 = np.log10(self.cls_priors[1]) + entry.dot(np.log10(self.cond_probs[1]))
prob_2 = np.log10(self.cls_priors[2]) + entry.dot(np.log10(self.cond_probs[2]))
if return_probs:
return sorted([(np.float_power(10, prob_0),0), (np.float_power(10, prob_1),1), (np.float_power(10, prob_2),2)], reverse=True)
return np.argmax((prob_0, prob_1, prob_2))
def trans_formula(self, freqs: np.ndarray, freq: float = 1.) -> np.ndarray:
'''
Make Fourier transformed morse wavelet.
'''
freqs = freqs / freq
step = np.heaviside(freqs, freqs)
wave = 2. * (step * np.float_power(freqs, self.b) * np.exp(
(self.b / self.r) * (1. - np.float_power(freqs, self.r))))
return wave
def load_model(self, filename, d):
self.model = None
self.init_model()
values = self.load_param_values(filename, d)
self.axes = OrderedDict()
for axis, labels in self.labels_t.items():
_, size = labels
assert size, "Size limit for '%s' axis labels is %s" % (axis, size)
self.axes[axis] = AxisModel(axis, size, self.config, self.model, self.birnn_type)
for model in self.sub_models():
model.load_sub_model(d, *values)
del values[:len(model.params)] # Take next len(model.params) values
if self.config.args.verbose <= 3:
self.config.print(model.params_str)
self.copy_shared_birnn(filename, d)
assert not values, "Loaded values: %d more than expected" % len(values)
if self.weight_decay and self.config.args.dynet_apply_weight_decay_on_load:
t = tqdm(list(self.all_params(as_array=False).items()),
desc="Applying weight decay of %g" % self.weight_decay, unit="param", file=sys.stdout)
for key, param in t:
t.set_postfix(param=key)
try:
value = param.as_array() * np.float_power(1 - self.weight_decay, self.updates)
except AttributeError:
continue
try:
param.set_value(value)
except AttributeError:
param.init_from_array(value)
self.config.print(self, level=1)
def estimate(self, query, logged_ranking, new_ranking, logged_value):
exactMatch=numpy.absolute(new_ranking-logged_ranking).sum() == 0
currentValue=0.0
if exactMatch:
numAllowedDocs=self.loggingPolicy.dataset.docsPerQuery[query]
validDocs=logged_ranking.size
invPropensity=None
if self.loggingPolicy.allowRepetitions:
invPropensity=numpy.float_power(numAllowedDocs, validDocs)
else:
invPropensity=numpy.prod(range(numAllowedDocs+1-validDocs, numAllowedDocs+1), dtype=numpy.float64)
currentValue=logged_value*invPropensity
self.updateRunningAverage(currentValue)
return self.runningMean
def pick_move(self, game, side):
possible_moves = game.possible_moves(side)
if len(possible_moves) == 0:
possible_moves.append((-1,-1))
monte_prob = self.monte_carlo(game, side)
if self.train:
self.temp_state.append((self.preprocess_input(game.board, side), np.divide(monte_prob, np.sum(monte_prob))))
monte_prob = np.float_power(monte_prob, 1/self.tau)
monte_prob = np.divide(monte_prob, np.sum(monte_prob))
r = random()
for i, move in enumerate(possible_moves):
r -= monte_prob[Othello.move_id(move)]
if r <= 0:
return move
return possible_moves[-1]
def month_pay(total, r, n):
return total * (r * numpy.float_power(1 + r, n))/(numpy.float_power(1 + r, n) -1 )
def weight_decay(model):
try:
return np.float_power(1 - model.classifier.weight_decay, model.classifier.updates)
except AttributeError:
return 1
def test_float_power_array(self):
assert np.all(np.float_power(np.array([1., 2., 3.]) * u.m, 3.)
== np.array([1., 8., 27.]) * u.m ** 3)
# regression check on #1696
assert np.all(np.float_power(np.arange(4.) * u.m, 0.) ==
1. * u.dimensionless_unscaled)
