def softmax_loss_vectorized(theta, X, y, reg):
"""
Softmax loss function, vectorized version.
Inputs and outputs are the same as softmax_loss_naive.
"""
# Initialize the loss and gradient to zero.
J = 0.0
grad = np.zeros_like(theta)
m, dim = X.shape
#############################################################################
# TODO: Compute the softmax loss and its gradient using no explicit loops. #
# Store the loss in J and the gradient in grad. If you are not careful #
# here, it is easy to run into numeric instability. Don't forget the #
# regularization term! #
#############################################################################
preds_col = (X@theta).T
exps_adj = np.exp(preds_col - np.amax(preds_col, axis=0))
ind = np.zeros_like(preds_col)
np.put_along_axis(ind, np.atleast_2d(y), 1, axis=0)
J = -1/m * np.sum(np.log(np.take_along_axis(exps_adj, np.atleast_2d(y), axis=0)/np.sum(exps_adj, axis=0)))
grad = -1/m * ((ind - exps_adj/np.sum(exps_adj, axis=0)) @ X).T
grad += reg/m * theta
#############################################################################
# END OF YOUR CODE #
#############################################################################
return J, grad
def optimize_T_fast(transition_matrix, values, eps_T, num_states, num_actions,
xv, yv):
T = transition_matrix.copy()
T_prev = np.ones_like(T)
diff = np.zeros([num_states, num_actions])
iters = 0
opt = np.argmax(values)
while np.any(np.abs(T - T_prev) > FLOAT_TOLERANCE):
T_prev = T.copy()
worst = np.argmin(np.where(T > FLOAT_TOLERANCE,
np.reshape(values, [1, 1, -1]), np.inf),
axis=2)
worst_i = (yv, xv, worst)
change = np.where(T[worst_i] < (eps_T - diff) / 2, T[worst_i],
(eps_T - diff) / 2)
T[:, :, opt] += change
# np.put(T, worst_i, T[worst_i] - change)
np.put_along_axis(T,
worst.reshape([num_states, num_actions, 1]),
(T[worst_i] - change).reshape(
[num_states, num_actions, 1]),
axis=2)
diff = np.linalg.norm(T - transition_matrix, 1, axis=2)
iters += 1
return T
def error_ambiguity(i, ensemble_proba, target):
'''
Compute the error for the individual classifier according to the ambiguity decomposition. I am fairly sure that this implementation is correct, however, the paper is not super clear on what they do from an algorithmic point of view. From what I can tell is, that the authors compute the ambiguity scores for each classifier only once and then "greedily" pick the best K models.
Note: The paper only considers binary classification problems and specifically focuses on the logistic loss function. Luckily, Hastie et al. proposed a multi-class boosting algorithm which uses a multi class variation of the (binary) logistic loss. Both loss functions are equal for 2 classes and thus we implement the multi-class version here. For more details see the reference.
Reference:
Jiang, Z., Liu, H., Fu, B., & Wu, Z. (2017). Generalized ambiguity decompositions for classification with applications in active learning and unsupervised ensemble pruning. 31st AAAI Conference on Artificial Intelligence, AAAI 2017, 2073–2079.
Hastie, T., Rosset, S., Zhu, J., & Zou, H. (2009). Multi-class AdaBoost. Statistics and Its Interface, 2(3), 349–360. https://doi.org/10.4310/sii.2009.v2.n3.a8
'''
iproba = ensemble_proba[i, :, :]
all_proba = ensemble_proba.mean(axis=0)
sqdiff = (iproba - all_proba)**2
C = iproba.shape[1]
A = 1.0 / C**2 * np.exp(-1.0 / C * iproba)
B = 1.0 / C**2 * (1.0 / (C - 1))**2 * np.exp(1.0 / C * 1.0 /
(C - 1) * iproba)
bitmask = np.zeros(A.shape)
# bitmask[:,target] = 1.0
np.put_along_axis(bitmask, target[:, None], 1.0, 1)
return (bitmask * A + (1.0 - bitmask) * B).sum() + sqdiff.sum()
def _CMI(self, x, y, i, j, cond):
'''
compute CMI for a list of conditions
'''
N = len(cond)
d = x.shape[1]
Nt = y.shape[1]
b2 = np.zeros([N, d + Nt], dtype=np.float32)
for n, c in enumerate(cond):
if c:
np.put_along_axis(b2[n], np.array(c), 1., 0)
m2 = b2.copy()
m2[:, i] = 1.
b1 = b2.copy()
b1[:, j] = 1.
m1 = b1.copy()
m1[:, i] = 1.
m = np.concatenate([m1, m2], axis=0) # [N*2, d]
b = np.concatenate([b1, b2], axis=0) # [N*2, d]
# run
B = self.hps.batch_size
num_batches = x.shape[0] // B
cmi_est = []
for n in range(num_batches):
xx = x[n * B:(n + 1) * B]
yy = y[n * B:(n + 1) * B]
cmi = self._batch_CMI(xx, yy, b, m)
cmi_est.append(cmi)
cmi_est = np.concatenate(cmi_est, axis=0)
cmi = np.mean(cmi_est, axis=0)
return cmi
def mutual_selection(score_mat):
"""
Return a {0,1} matrix, the element is 1 if and only if it's maximum along both row and column
Args: np.array()
score_mat: [B,N,N]
Return:
mutuals: [B,N,N]
"""
score_mat = to_array(score_mat)
if (score_mat.ndim == 2):
score_mat = score_mat[None, :, :]
mutuals = np.zeros_like(score_mat)
for i in range(score_mat.shape[0]): # loop through the batch
c_mat = score_mat[i]
flag_row = np.zeros_like(c_mat)
flag_column = np.zeros_like(c_mat)
max_along_row = np.argmax(c_mat, 1)[:, None]
max_along_column = np.argmax(c_mat, 0)[None, :]
np.put_along_axis(flag_row, max_along_row, 1, 1)
np.put_along_axis(flag_column, max_along_column, 1, 0)
mutuals[i] = (flag_row.astype(np.bool)) & (flag_column.astype(np.bool))
return mutuals.astype(np.bool)
def softmax_with_cross_entropy(predictions, target_index):
"""
Computes softmax and cross-entropy loss for model predictions,
including the gradient
Arguments:
predictions, np array, shape is either (N) or (batch_size, N) -
classifier output
target_index: np array of int, shape is (1) or (batch_size) -
index of the true class for given sample(s)
Returns:
loss, single value - cross-entropy loss
dprediction, np array same shape as predictions - gradient of loss by predictions
"""
y_true = np.zeros(predictions.shape)
if predictions.ndim == 1:
y_true[target_index] = 1
else:
target_index_vect = target_index.reshape(-1, 1)
np.put_along_axis(y_true, target_index_vect, 1, axis=1)
probs = softmax(predictions)
loss = cross_entropy_loss(probs, target_index)
dprediction = (probs - y_true)
if predictions.ndim != 1:
dprediction /= predictions.shape[0]
return loss, dprediction
def replay(self, batch_size):
minibatch = random.sample(self.memory, min(len(self.memory),
batch_size))
batch_states = np.array([i[0] for i in minibatch]).reshape(
(len(minibatch), 84, 84, 4))
batch_actions = np.array([i[1] for i in minibatch]).reshape(
(len(minibatch), 1, 1))
batch_rewards = np.array([i[2] for i in minibatch]).reshape(
(len(minibatch), 1, 1))
batch_next_states = np.array([i[3] for i in minibatch]).reshape(
(len(minibatch), 84, 84, 4))
batch_dones = np.array([i[4] for i in minibatch]).reshape(
(len(minibatch), 1, 1))
random_states = self.model.get_nprandomstates()
y_target = self.model.feedforward(batch_states)
target = (
batch_rewards + (np.invert(batch_dones) * (self.gamma * np.amax(
self.model.feedforward(batch_next_states), 1, keepdims=True)))
).reshape((len(minibatch), 1, 1))
np.put_along_axis(y_target, batch_actions, target, 1)
self.model.sgd_fit(batch_states,
y_target,
batch_size=batch_size,
epochs=1,
train_pct=1.0,
shuffle_inputs=False,
random_states=random_states)
if self.epsilon > self.epsilon_min:
self.epsilon *= self.epsilon_decay
def evaluate_array(self, us, vs):
result = np.empty((len(us), 3))
v_to_u = defaultdict(list)
v_to_i = defaultdict(list)
for i, (u, v) in enumerate(zip(us, vs)):
v_to_u[v].append(u)
v_to_i[v].append(i)
# here we rely on fact that in Python 3.7+ dicts are ordered.
all_vs = np.array(list(v_to_u.keys()))
v_spline_points = np.array(
[spline.evaluate_array(all_vs) for spline in self.v_splines])
for v_idx, (v, us_by_v) in enumerate(v_to_u.items()):
is_by_v = v_to_i[v]
spline_vertices = []
for spline_idx, spline in enumerate(self.v_splines):
point = v_spline_points[spline_idx, v_idx]
#point = spline.evaluate(v)
spline_vertices.append(point)
u_spline = self.get_u_spline(v, spline_vertices)
points = u_spline.evaluate_array(np.array(us_by_v))
idxs = np.array(is_by_v)[np.newaxis].T
np.put_along_axis(result, idxs, points, axis=0)
return result
def analyse(self, a):
g = np.copy(a)
#set blue and red channels to 0
g[:, :, 0] = 0
g[:, :, 2] = 0
GBthreshold = 50
GB = np.where(g>GBthreshold,255,0)
GBB = np.where(g>GBthreshold,1,0)
GBB = GBB[:,:,1]
GB2 = GB[:,:,1]
# GREEN
sumG2 = np.sum(GBB, axis=0)
sumsizeG = sumG2.size
xaxis = np.argmax(sumG2, axis=0)
print("x: ")
print(xaxis)
sumG1 = np.sum(GBB, axis=1)
sumsizeG1 = sumG1.size
yaxis = np.argmax(sumG1, axis=0)
print("y: ")
print(yaxis)
GreenFound = GB2
dimG1 = 320
dimG2 = 192
indices1 = np.ones((dimG2,dimG1),dtype = np.int) * yaxis
indices2 = np.ones((dimG2,dimG1),dtype = np.int) * xaxis
np.put_along_axis(GreenFound,indices1,255,axis=0)
np.put_along_axis(GreenFound,indices2,255,axis=1)
GreenFound = GreenFound.astype(np.uint8)
cv2.imshow('image',GreenFound)
cv2.waitKey(1)
cv2.imwrite('GreenFound.png',GreenFound)
anglepwm = translate(xaxis, 0, 320, 65, 0)
#if dot is gone then steer to middle
if anglepwm == 65:
anglepwm = 33
SetAngle(anglepwm)
print("Servo value: ")
print(anglepwm)
print("")
def move_nodes(mesh, beta, second=False):
d, nn, nc = mesh.dimension, mesh.nnodes, mesh.ncells
assert beta.shape == (nc, d)
lambdas = np.eye(d + 1)
md = MoveData(nn, d, second=second)
for i in range(mesh.ncells):
betacoef = _coef_beta_in_simplex(i, mesh, beta[i])
for ipl in range(d + 1):
delta, mu = _move_in_simplex_opt(lambdas[ipl], betacoef)
if delta > 0:
ip = mesh.simplices[i, ipl]
md.cells[ip] = i
md.deltas[ip] = delta
md.mus[ip] = mu
ind = np.argmin(md.mus, axis=1)
# print(f"{md.mus.shape=} {ind.shape=}")
np.put_along_axis(md.mus, ind[:, np.newaxis], 0, axis=1)
if second:
for ip in range(nn):
ic = md.cells[ip]
if ic == md.imax: continue
indf = mesh.facesOfCells[ic, md.mus[ip] == 0]
ic2 = mesh.cellsOfFaces[indf, 0][0]
if ic2 == ic: ic2 = mesh.cellsOfFaces[indf, 1][0]
if ic2 < 0: continue
# print(f"{ic2=}")
mu2 = _coef_mu_in_neighbor(mesh, ic2, ic, md.mus[ip])
betacoef = _coef_beta_in_simplex(ic2, mesh, beta[ic])
delta, mu = _move_in_simplex_opt(mu2, betacoef)
# print(f"{delta=} {betacoef=} {md.mus[ip]} {mu=}")
if delta > 0.1 * md.deltas[ip] / np.sqrt(2):
md.cells2[ip] = ic2
md.deltas2[ip] = delta
md.mus2[ip] = mu
return md
def normalize_activation(arr, threshold=0.5, mono=False):
"""
:param mono:
:param arr: (nb_instruments, (batch=1), nb_steps=1, length, 88, 2)
:param threshold:
:return: the same array but only with one and zeros for the activation part ([:, :, :, 0])
"""
if mono:
axis = len(arr.shape) - 2
argmax = np.argmax(arr, axis=axis)
new_arr = np.zeros(arr.shape)
idx = list(np.ogrid[[
slice(arr.shape[ax]) for ax in range(arr.ndim) if ax != axis
]])
idx.insert(axis, argmax)
new_arr[tuple(idx)] = 1
else:
activations = np.take(arr, axis=-1, indices=0)
np.place(activations, threshold <= activations, 1)
np.place(activations, activations < threshold, 0)
np.put_along_axis(arr=arr,
indices=np.zeros(tuple(1 for i in arr.shape),
dtype=int),
values=np.expand_dims(activations, axis=-1),
axis=-1)
new_arr = arr
return new_arr
def observe(
self,
action: types.NestedArray,
next_timestep: dm_env.TimeStep,
):
action = np.expand_dims(action, axis=-1)
next_rewards = np.expand_dims(next_timestep.reward, axis=-1)
is_first = np.expand_dims(next_timestep.first(), axis=-1) # for mask
avg_rewards = np.take_along_axis(self._avg_rewards, action, axis=-1)
counts = np.take_along_axis(self._counts, action, axis=-1)
# Compute & update avg rewards.
update_values = 1 / counts * (next_rewards - avg_rewards)
next_avg_rewards = avg_rewards + np.where(
is_first, 0, update_values) # skip first timestep.
np.put_along_axis(self._avg_rewards,
action,
values=next_avg_rewards,
axis=-1)
# Update counts.
np.put_along_axis(self._counts,
action,
values=counts + (1 - is_first),
axis=-1)
self._total_counts += (1 - is_first).squeeze()
def train_eval_bert(params, df, train, test, evaluate=True):
train_dataset, val_dataset, MAX_LEN = create_train_val(
df['content'], df['labels'], train, test)
print("training bert with these params")
print(params)
model = init_model('distilbert-base-uncased', len(targets), params)
model.fit(train_dataset.shuffle(100).batch(params['batch_size']),
epochs=params['num_epochs'],
batch_size=params['batch_size'],
class_weight=params['class_weight'])
preds = model.predict(val_dataset.batch(1)).logits
y_pred = tf.keras.activations.sigmoid(tf.convert_to_tensor(preds)).numpy()
ai = np.expand_dims(np.argmax(y_pred, axis=1), axis=1)
maximums = np.maximum(y_pred.max(1), 0.51)
np.put_along_axis(y_pred, ai, maximums.reshape(ai.shape), axis=1)
if evaluate:
eps = evaluate_preds(df['relevant'][test], y_pred[:, 0])
for key, value in params.items():
eps[key] = value
return eps, y_pred
else:
return y_pred
def fit(self, X, y: np.uint8):
# label validation
y = check_array(y, dtype='uint8', ensure_2d=False)
if len(y.shape) == 1:
y = y.reshape(-1, 1)
# get classes
self.classes_ = list(range(0, y.max() + 1))
# Check that X and y have correct shape
X, y = check_X_y(X, y, y_numeric=True, multi_output=True)
# create one hot encoded matrix
y_encoded = np.zeros((len(y), len(self.classes_)))
# put on correct columns 1 value
np.put_along_axis(y_encoded, y, 1, axis=1)
# add bias to X
X = np.hstack((np.ones((X.shape[0], 1)), X))
# generate random matrix if it does not exist or it is a different size
rng = np.random.default_rng(seed=self.seed)
self.V_ = rng.normal(scale=0.2, size=(X.shape[1], self.neurons))
# calculate activator for mid-layer
#H = np.tanh(X.dot(self.V_))
# add bias to H
H = np.append(np.ones((X.shape[0], 1)), np.tanh(X.dot(self.V_)), axis=1)
# if n <= N
if self.neurons <= X.shape[0]:
# w = (h_t*h + gamma*I)^-1 * h_t*y
self.weights_ = np.linalg.inv(H.transpose().dot(H) + self.gamma * np.identity(H.shape[1])).dot(
H.transpose().dot(y_encoded))
else:
# n > N
# w = h_t(h*h_t + gamma*I)^-1 * y
self.weights_ = H.transpose().dot(
np.linalg.inv(H.dot(H.transpose()) + self.gamma * np.identity(H.shape[1]))).dot(y_encoded)
return self
def cost(outputs: np.ndarray, label: np.ndarray) -> np.ndarray:
"""
Cross entropy cost function, consumes 2d array of outputs and 1d array of expected values.
"""
y = np.zeros(outputs.shape).reshape(-1, 10)
np.put_along_axis(y, label.reshape(-1, 1), 1, axis=1)
return -np.nan_to_num(np.sum(y * np.log(outputs) + (1 - y) * np.log(1 - outputs), axis=1))
def prime(outputs: np.ndarray, label: np.ndarray) -> np.ndarray:
"""
Derivative of cross entropy cost function, consumes 2d array of outputs and 1d array of expected values.
"""
y = np.zeros(outputs.shape).reshape(-1, 10)
np.put_along_axis(y, label.reshape(-1, 1), 1, axis=1)
return -(y - outputs) / (outputs * (1 - outputs))
def cost(outputs: np.ndarray, label: np.ndarray) -> np.ndarray:
"""
Quadratic cost function, consumes 2d array of outputs and 1d array of expected values
"""
y = np.zeros(outputs.shape).reshape(-1, 10) # Generate zeros array of same shape as output
np.put_along_axis(y, label.reshape(-1, 1), 1, axis=1) # Place a 1 at the label index of each array of y
return np.mean((outputs - y) ** 2, axis=1) / 2
def train_age_regressor ():# train_age_regressor()
# Load data
X_tr_raw = (np.load("fashion_mnist_train_images.npy"))
y_tr_raw = np.load("fashion_mnist_train_labels.npy")
X_te_raw = (np.load("fashion_mnist_test_images.npy"))
y_te_raw = np.load("fashion_mnist_test_labels.npy")
no_data = X_tr_raw.shape[0]
brightness_value = 256
X_te = X_te_raw/brightness_value
X_tr = X_tr_raw/brightness_value
y_tr = np.zeros([X_tr_raw.shape[0], no_of_classes])
y_tr_raw = (np.atleast_2d(y_tr_raw).T)
np.put_along_axis(y_tr, y_tr_raw, 1, axis=1)
y_te = np.zeros([X_te_raw.shape[0], no_of_classes])
y_te_raw = (np.atleast_2d(y_te_raw).T)
np.put_along_axis(y_te, y_te_raw, 1, axis=1)
# X_show = (X_tr_raw[40].reshape((28, 28)))
# plt.imshow(X_show, interpolation='nearest', cmap='gray', vmin=0, vmax=255)
# plt.show()
w,b = stoch_grad_regression(X_tr, y_tr)
testing_age = test_data(X_te, y_te, w, b)
print("################################")
print("FINAL TESTING ERROR:", testing_age)
print("################################")
def generate_sample(self, epoch):
c = 7
r = 7
z = np.random.uniform(-1, 1, (self.batch_size, self.z_shape))
z[:, :10] = 0.
y = np.random.randint(10, size=self.batch_size)
np.put_along_axis(z, y[..., np.newaxis], 1, axis=1)
imgs = self.sess.run(self.gen_out, feed_dict={self.phZ:z})
imgs = imgs*0.5 + 0.5
result = np.argmax(imgs[:, :, -1, 0], axis=1)
self.matching = np.sum(y == result)
# scale between 0, 1
fig, axs = plt.subplots(c, r)
fig.suptitle(f"Matching indices: {self.matching}")
cnt = 0
for i in range(c):
for j in range(r):
axs[i, j].imshow(imgs[cnt, :, :, 0], cmap="gray")
axs[i, j].axis('off')
# if discs[cnt]:
# col = 'g'
# else:
# col = 'r'
axs[i, j].set_title(str(y[cnt]), size=7, pad=0.5) #, color = col)
axs[i, j].text(30, 13.5, str(result[cnt]), size=7,
verticalalignment='center')
cnt += 1
fig.savefig("samples/targets_swapped_" + str(epoch).zfill(len(str(self.epochs))) + ".png")
plt.close()
def normal_array(self, us, vs):
h = 0.001
result = np.empty((len(us), 3))
v_to_u = defaultdict(list)
v_to_i = defaultdict(list)
for i, (u, v) in enumerate(zip(us, vs)):
v_to_u[v].append(u)
v_to_i[v].append(i)
for v, us_by_v in v_to_u.items():
us_by_v = np.array(us_by_v)
is_by_v = v_to_i[v]
spline_vertices = []
spline_vertices_h = []
for v_spline in self.v_splines:
v_min, v_max = v_spline.get_u_bounds()
vx = (v_max - v_min) * v + v_min
point = v_spline.evaluate(vx)
point_h = v_spline.evaluate(vx + h)
spline_vertices.append(point)
spline_vertices_h.append(point_h)
u_spline = self.get_u_spline(v, spline_vertices)
u_spline_h = self.get_u_spline(v+h, spline_vertices_h)
points = u_spline.evaluate_array(us_by_v)
points_v_h = u_spline_h.evaluate_array(us_by_v)
points_u_h = u_spline.evaluate_array(us_by_v + h)
dvs = (points_v_h - points) / h
dus = (points_u_h - points) / h
normals = np.cross(dus, dvs)
norms = np.linalg.norm(normals, axis=1, keepdims=True)
normals = normals / norms
idxs = np.array(is_by_v)[np.newaxis].T
np.put_along_axis(result, idxs, normals, axis=0)
return result
def minmax(data, mask=None, variance=None, nlow=0, nhigh=0):
# minmax rejection, following IRAF rules when pixels are rejected
# We flag the pixels to be rejected as DQ.bad_pixel. For any pixels
# to be flagged this way, there have to be good (or nonlin/saturated)
# pixels around so they will get combined before the DQhierarchy
# looks at DQ.bad_pixel
num_img = data.shape[0]
if nlow + nhigh >= num_img:
raise ValueError("Only {} images but nlow={} and nhigh={}".format(
num_img, nlow, nhigh))
if mask is None:
nlo = int(nlow + 0.001)
nhi = data.shape[0] - int(nhigh + 0.001)
# Sorts data and apply this to the mask
arg = np.argsort(data, axis=0)
mask = np.zeros_like(data, dtype=bool)
np.put_along_axis(mask, arg[:nlo], True, axis=0)
np.put_along_axis(mask, arg[nhi:], True, axis=0)
else:
# Because I'm sorting, I'll put large dummy values in a numpy array
# Have to keep all values if all values are masked!
# Sorts variance and mask with data
arg = np.argsort(np.where(mask == DQ.max, np.inf, data), axis=0)
# IRAF imcombine maths
num_good = NDStacker._num_good(mask == DQ.max)
nlo = (num_good * nlow / num_img + 0.001).astype(int)
nhi = num_good - (num_good * nhigh / num_img +
0.001).astype(int) - 1
arg2 = np.argsort(arg, axis=0)
mask[arg2 < nlo] = DQ.max
mask[(arg2 > nhi) & (arg2 < num_good)] = DQ.max
return data, mask, variance
def change_channel(image, channel_id, percentage):
"""Modifies an output channel by multiplying it by a percentage."""
mask = np.ones(image.shape, dtype=float)
indices = channel_id * np.ones((image.shape[0], image.shape[1], 1),
dtype=int)
np.put_along_axis(mask, indices, percentage, axis=2)
return np.clip((image * mask).astype(int), 0, 255)
def grad_fn_left(grad: Array) -> Array:
adjoint = np.zeros_like(input.data)
np.put_along_axis(adjoint, target_exp, -1, axis=1)
adjoint += special.softmax(input.data, axis=1)
adjoint /= np.prod(input.shape) / input.shape[1]
return grad * adjoint
def _lle(self, idx_nn):
nn = self.X_fit[idx_nn] # (N, n_neighbors, n_features)
Z = nn - np.expand_dims(self.X_fit, 1) # (N, n_neighbors, n_features)
G = np.matmul(Z,
np.transpose(Z,
(0, 2, 1))) # (N, n_neighbors, n_neighbors)
one = np.ones((len(self.X_fit), self.n_neighbors, 1))
G_ = np.linalg.pinv(G)
a = np.matmul(G_, one) # (N, n_neighbors, 1)
b = np.matmul(np.matmul(np.transpose(one, [0, 2, 1]), G_),
one) # (N, 1, 1)
value = np.squeeze(a / b, 2) # (N, n_neighbors, 1)
W = np.zeros((len(self.X_fit), len(self.X_fit)))
np.put_along_axis(W, idx_nn, value, 1)
I = np.eye(len(self.X_fit))
tmp = I - W
M = np.matmul(tmp.T, tmp)
evl, evc = sp.linalg.eigh(
M,
subset_by_index=(self.k_skip, self.n_components + self.k_skip - 1))
idx = np.abs(evl).argsort()
evl, evc = evl[idx], evc[:, idx]
self.embeddings = evc[:, :self.n_components]
return self.embeddings
def _fix_number_of_classes(
self,
n_classes_training: NDArray,
y_proba: NDArray
) -> NDArray:
"""
Fix shape of y_proba of validation set if number of classes
of the training set used for cross-validation is different than
number of classes of the original dataset y.
Parameters
----------
n_classes_training : NDArray
Classes of the training set.
y_proba : NDArray
Probabilities of the validation set.
Returns
-------
NDArray
Probabilities with the right number of classes.
"""
y_pred_full = np.zeros(
shape=(len(y_proba), self.n_classes_)
)
y_index = np.tile(n_classes_training, (len(y_proba), 1))
np.put_along_axis(
y_pred_full,
y_index,
y_proba,
axis=1
)
return y_pred_full
def softmax_with_cross_entropy(predictions, target_index):
"""
Computes softmax and cross-entropy loss for model predictions,
including the gradient
Arguments:
predictions, np array, shape is either (N) or (batch_size, N) -
classifier output
target_index: np array of int, shape is (1) or (batch_size) -
index of the true class for given sample(s)
Returns:
loss, single value - cross-entropy loss
dprediction, np array same shape as predictions - gradient of predictions by loss value
"""
# Softmax and cross-entropy loss
probs = softmax(predictions)
loss = cross_entropy_loss(probs, target_index)
# Gradient
dprediction = np.zeros(probs.shape)
if isinstance(target_index, int):
dprediction[target_index] = 1
dprediction = probs - dprediction
else:
if target_index.ndim == 1:
target_index = target_index[:, None]
np.put_along_axis(dprediction, target_index, 1, axis=1)
dprediction = (probs - dprediction) / dprediction.shape[0]
return loss, dprediction
def gen() -> Generator[SignalDataFrame, None, None]:
for i in range(n_samples):
data = np.random.randint(0, modulator.n_channels, sample_len,
np.int32)
target_one_hot = np.zeros((sample_len, modulator.n_channels),
dtype=np.float32)
np.put_along_axis(target_one_hot,
np.expand_dims(data, 1),
1,
axis=1)
wave = modulator.modulate(data)
if add_noise is not None:
wave = add_noise(wave)
wave = np.expand_dims(wave, 1)
x = wave
if return_sg:
spectrogram = modulator.wave_to_spectrogram(wave.ravel()).T
spectrogram = np.expand_dims(spectrogram, 2)
if normalize:
_norm_spectrogram(spectrogram)
x = (wave, spectrogram) if return_wave else spectrogram
if normalize:
_norm_wave(wave)
yield x, target_one_hot
def _get_ndarray(self, statuses, revcomp=False):
"""
`statuses` is an N-array of 1s and 0s, denoting positives and negatives.
Returns a NumPy array of one-hot encoded sequences parallel to
`statuses` (i.e. wherever there is a 0, a negative sequence is returned,
and wherever there is a 1, a positive sequence with a motif is
returned). If `revcomp` is True, also include the reverse complement
sequences concatenated at the end (i.e. the returned array will be
twice as long as `statuses`).
"""
onehot = np.empty((len(statuses), self.sequence_length, 4))
pos_inds = np.where(statuses == 1)[0]
neg_inds = np.where(statuses == 0)[0]
if len(pos_inds):
pos_onehot = self._get_one_hot_seqs(self.pos_seq_generator,
len(pos_inds))
np.put_along_axis(onehot,
pos_inds[:, None, None],
pos_onehot,
axis=0)
if len(neg_inds):
neg_onehot = self._get_one_hot_seqs(self.neg_seq_generator,
len(neg_inds))
np.put_along_axis(onehot,
neg_inds[:, None, None],
neg_onehot,
axis=0)
if revcomp:
rc = onehot[:, ::-1, ::-1]
onehot = np.concatenate([onehot, rc])
return onehot
def filter_to_topp(top_p, dist):
"""
Args:
top_k (int):
dist (torch.Tensor): (num_batch, -1) dimensioned torch tensor.
Returns:
torch.Tensor: (num_batch, -1) dimensioned torch tensor.
"""
dist = np.copy(dist)
batch_size = dist.shape[0]
sorted_index = np.argsort(-dist)
sorted_value = np.take_along_axis(dist, sorted_index, axis=-1)
sorted_prob = softmax(sorted_value, axis=1)
sorted_prob_cumsum = np.cumsum(sorted_prob, axis=-1)
# shift right side
# Algorithm
# cumsum = [0.1, 0.3, 0.93, 0.1] and top_p = 0.9
# cumsum > top_p -> [False, False, True, True]
# shift -> [False, False, False, True]
sorted_index_mask = np.concatenate([
np.full((batch_size, 1), False), (sorted_prob_cumsum > top_p)[:, :-1]
],
axis=-1)
mask = np.full(dist.shape, False)
np.put_along_axis(mask, sorted_index, sorted_index_mask, axis=-1)
dist[mask] = -float("Inf")
return dist
def w2t_boson(I, beta, axis):
Ishape = np.shape(I)
dim = len(Ishape)
N = 2 * (Ishape[axis] - 1)
delta = beta / N
w = np.fft.fftfreq(N, beta / (np.pi * 2 * N))
theta = w * delta
indices = expand(np.arange(N // 2 - 1, 0, -1), axis, dim)
I = np.concatenate((I, np.take_along_axis(np.conj(I), indices, axis)),
axis)
I = I / (delta * expand(W_boson(theta), axis, dim))
shape = np.array(np.shape(I))
shape[axis] = N + 1
out = np.zeros(shape, dtype=complex)
indices = expand(np.arange(N), axis, dim)
np.put_along_axis(out, indices, np.fft.fft(I, axis=axis) / N, axis)
indices = expand(np.arange(N, N + 1), axis, dim)
np.put_along_axis(
out, indices,
np.take_along_axis(out, expand(np.arange(1), axis, dim), axis), axis)
return out
def agregar(símismo, nuevos, edad=0, etapas=None):
# Limpiar edades de cohortes
símismo._edades[símismo._pobs == 0] = 0
if etapas is None:
rbn = slice(None)
nuevos = símismo._proc_matr_datos(nuevos)
else:
rbn = símismo.rebanar(etapas)
# Las edades y las poblaciones actuales de las etapas
pobs = símismo._pobs[rbn]
edades = símismo._edades[rbn]
eje_coh = símismo.eje_coh()
# Los índices de los días cuyos cohortes tienen la edad mínima. Si hay más que un día (cohorte) con la
# edad mínima, tomará el primero.
í_cohs = np.expand_dims(np.argmin(edades, axis=eje_coh), axis=eje_coh)
# Las edades de los cohortes con las edades mínimas.
eds_mín = np.take_along_axis(edades, í_cohs, axis=eje_coh)
# Las poblaciones que corresponden a estas edades mínimas.
pobs_coresp = np.take_along_axis(pobs, í_cohs, axis=eje_coh)
# Dónde no hay población existente, reinicializamos la edad.
eds_mín = np.where(pobs_coresp == 0, [0], eds_mín)
# Calcular el peso de las edades existentes, según sus poblaciones existentes (para combinar con el nuevo
# cohorte si hay que combinarlo con un cohorte existente).
peso_ed_ya = np.divide(pobs_coresp, np.add(nuevos, pobs_coresp))
peso_ed_ya[np.isnan(peso_ed_ya)] = 0
# Los edades promedios. Si no había necesidad de combinar cohortes, será la población del nuevo cohorte.
eds_prom = np.add(np.multiply(eds_mín, peso_ed_ya), np.multiply(edad, np.subtract(1, peso_ed_ya)))
# Guardar las edades actualizadas en los índices apropiados
np.put_along_axis(edades, í_cohs, eds_prom, axis=eje_coh)
# Guardar las poblaciones actualizadas en los índices apropiados
np.put_along_axis(pobs, í_cohs, nuevos + pobs_coresp, axis=eje_coh)
símismo._pobs[rbn] = pobs
símismo._edades[rbn] = edades