def test_ars_optimizer(self): dim = 10 n_generations = 30 X = torch.Tensor([[i] for i in range(dim)]) y = torch.ones(dim) n_pert = 100 feature_dim = 2 np.random.seed(seed=123456) ars_opt = ARSOptimizer(feature_dim, n_pert, rand_ars_params=True) for i in range(n_generations): perturbed_params = ars_opt.sample_perturbed_params() rewards = [] for idx in range(0, len(perturbed_params)): pos_param, neg_param = perturbed_params[idx] pos_weight = torch.sigmoid( torch.matmul(torch.column_stack((X, y)), pos_param)) # ARSOptimizer works in an ascent manner, # thus a neg sign for minimizing objectives. r_pos = -self.metric(pos_weight.numpy()) rewards.append(r_pos) neg_weight = torch.sigmoid( torch.matmul(torch.column_stack((X, y)), neg_param)) r_neg = -self.metric(neg_weight.numpy()) rewards.append(r_neg) ars_opt.update_ars_params(torch.Tensor(rewards)) new_weight = torch.sigmoid( torch.matmul( torch.column_stack((X, y)), torch.from_numpy(ars_opt.ars_params).float(), )) perf = self.metric(new_weight.numpy()) print(f"gen {i}: perf {perf}") self.assertLessEqual(perf, 1e-15)
def forward(self, data): if self.training: return self.main(data) out = self.main[0](data) out1 = self.main[1](out) out2 = self.main[2](out1) out3 = self.main[3](out2) out4 = self.main[4](out3) out5 = self.main[5](out4) out6 = self.main[6](out5) out7 = self.main[7](out6) mp1 = nn.MaxPool2d(kernel_size=2, padding=0) mp2 = nn.MaxPool2d(kernel_size=2, padding=0) mp3 = nn.MaxPool2d(kernel_size=2, padding=0) if self.data_generation_mode is 1: flt1 = mp1(out1).flatten(start_dim=1) flt2 = mp2(out4).flatten(start_dim=1) flt3 = mp3(out7).flatten(start_dim=1) else: flt1 = mp1(out).flatten(start_dim=1) flt2 = mp2(out2).flatten(start_dim=1) flt3 = mp3(out5).flatten(start_dim=1) flt21 = torch.column_stack((flt1, flt2)) final = torch.column_stack((flt21, flt3)) return final
def tensor_indexing_ops(self): x = torch.randn(2, 4) y = torch.randn(2, 4, 2) t = torch.tensor([[0, 0], [1, 0]]) mask = x.ge(0.5) i = [0, 1] return ( torch.cat((x, x, x), 0), torch.concat((x, x, x), 0), torch.conj(x), torch.chunk(x, 2), torch.dsplit(y, i), torch.column_stack((x, x)), torch.dstack((x, x)), torch.gather(x, 0, t), torch.hsplit(x, i), torch.hstack((x, x)), torch.index_select(x, 0, torch.tensor([0, 1])), torch.masked_select(x, mask), torch.movedim(x, 1, 0), torch.moveaxis(x, 1, 0), torch.narrow(x, 0, 0, 2), torch.nonzero(x), torch.permute(x, (0, 1)), torch.reshape(x, (-1, )), )
def custom_izhikevich_step( input_current: torch.Tensor, s: CustomIzhikevichState, p: IzhikevichParameters, dt: float = 0.001, ) -> Tuple[torch.Tensor, CustomIzhikevichState]: v_ = s.v + p.tau_inv * dt * (p.sq * s.v**2 + p.mn * s.v + p.bias - s.u + input_current) u_ = s.u + p.tau_inv * dt * p.a * (p.b * s.v - s.u) z_ = heaviside(v_ - p.v_th) v_ = (1 - z_) * v_ + z_ * p.c u_ = (1 - z_) * u_ + z_ * (u_ + p.d) # Todo Q:should this happen before or after membrane reset? # > given OSTL paper this should happen after Cell computation s_ = CustomIzhikevichState(v_, u_, s.e) if s_.e.numel() > 0: last_e = s_.e[:, -1:] # last eligibility trace else: last_e = None e_ = compute_eligibility_vector(s_, p, dt, last_e) if s_.e.numel() > 0: e_ = torch.column_stack((s_.e, e_)) else: e_ = torch.unsqueeze(e_, 0) return z_, CustomIzhikevichState(v_, u_, e_)
def get_gap_segments(segments: torch.Tensor) -> torch.Tensor: """ Get the gap segments. For example, torch.Tensor([[start1, end1], [start2, end2], [start3, end3]]) -> torch.Tensor([[end1, start2], [end2, start3]]) """ segments = segments[segments[:, 0].sort()[1]] return torch.column_stack((segments[:-1, 1], segments[1:, 0]))
def forward(self, screens, states): c = self.fe(screens) # extract features from pixel input c = self.fc(torch.column_stack([c, states])) mu = self.mu(c) var = self.var(c) v = self.val(c) p = self.p(c) return mu, var, v, p
def tensor_indexing_ops(self): x = torch.randn(2, 4) y = torch.randn(4, 4) t = torch.tensor([[0, 0], [1, 0]]) mask = x.ge(0.5) i = [0, 1] return len( torch.cat((x, x, x), 0), torch.concat((x, x, x), 0), torch.conj(x), torch.chunk(x, 2), torch.dsplit(torch.randn(2, 2, 4), i), torch.column_stack((x, x)), torch.dstack((x, x)), torch.gather(x, 0, t), torch.hsplit(x, i), torch.hstack((x, x)), torch.index_select(x, 0, torch.tensor([0, 1])), x.index(t), torch.masked_select(x, mask), torch.movedim(x, 1, 0), torch.moveaxis(x, 1, 0), torch.narrow(x, 0, 0, 2), torch.nonzero(x), torch.permute(x, (0, 1)), torch.reshape(x, (-1, )), torch.row_stack((x, x)), torch.select(x, 0, 0), torch.scatter(x, 0, t, x), x.scatter(0, t, x.clone()), torch.diagonal_scatter(y, torch.ones(4)), torch.select_scatter(y, torch.ones(4), 0, 0), torch.slice_scatter(x, x), torch.scatter_add(x, 0, t, x), x.scatter_(0, t, y), x.scatter_add_(0, t, y), # torch.scatter_reduce(x, 0, t, reduce="sum"), torch.split(x, 1), torch.squeeze(x, 0), torch.stack([x, x]), torch.swapaxes(x, 0, 1), torch.swapdims(x, 0, 1), torch.t(x), torch.take(x, t), torch.take_along_dim(x, torch.argmax(x)), torch.tensor_split(x, 1), torch.tensor_split(x, [0, 1]), torch.tile(x, (2, 2)), torch.transpose(x, 0, 1), torch.unbind(x), torch.unsqueeze(x, -1), torch.vsplit(x, i), torch.vstack((x, x)), torch.where(x), torch.where(t > 0, t, 0), torch.where(t > 0, t, t), )
def forward(self, screens, states): """ - screen is the pixel observation - obs is the concatenated current and target state Returns: combined features of the entire observation """ c = self.conv(screens).view(screens.size()[0], -1) c = torch.column_stack([self.fc1(c), states]) # return self.fc2(c) return c
def compute_metrics(truth: FullCatalog, pred: FullCatalog): # prepare magnitude bins mag_cuts2 = torch.arange(18, 24.5, 0.25) mag_cuts1 = torch.full_like(mag_cuts2, fill_value=-np.inf) mag_cuts = torch.column_stack((mag_cuts1, mag_cuts2)) mag_bins2 = torch.arange(18, 25, 1.0) mag_bins1 = mag_bins2 - 1 mag_bins = torch.column_stack((mag_bins1, mag_bins2)) # compute metrics cuts_data = compute_mag_bin_metrics(mag_cuts, truth, pred) bins_data = compute_mag_bin_metrics(mag_bins, truth, pred) # data for scatter plot of misclassifications (over all magnitudes). tplocs = truth.plocs.reshape(-1, 2) eplocs = pred.plocs.reshape(-1, 2) tindx, eindx, dkeep, _ = reporting.match_by_locs(tplocs, eplocs, slack=1.0) # compute egprob separately for PHOTO egbool = pred["galaxy_bools"].reshape(-1)[eindx][dkeep] egprob = pred.get("galaxy_probs", None) egprob = egbool if egprob is None else egprob.reshape(-1)[eindx][dkeep] full_metrics = { "tgbool": truth["galaxy_bools"].reshape(-1)[tindx][dkeep], "egbool": egbool, "egprob": egprob, "tmag": truth["mags"].reshape(-1)[tindx][dkeep], "emag": pred["mags"].reshape(-1)[eindx][dkeep], } return { "mag_cuts": mag_cuts2, "mag_bins": mag_bins2, "cuts_data": cuts_data, "bins_data": bins_data, "full_metrics": full_metrics, }
def to_corner_parametrization(bounding_box: Tensor) -> Tensor: """ Converts from center/side-lengths parametrization to corners coordinates :param bounding_box: tensor [N, 4] of bounding boxes parameters in the form [x-coordinate of center, y-coordinate of center, width, height] :return: tensor [N, 4] of bounding box parameters in the form [x-coordinate of top left corner, y-coordinate of top left corner, x-coordinate of bottom right corner, y-coordinate of bottom right corner] """ center_x, center_y, width, height = bounding_box.T half_w, half_h = width / 2, height / 2 top_left_x, top_left_y = center_x - half_w, center_y - half_h bottom_right_x, bottom_right_y = center_x + half_w, center_y + half_h return torch.column_stack( (top_left_x, top_left_y, bottom_right_x, bottom_right_y))
def training_step(self, batch, batch_idx): x, y = batch y_pred = self(x) pixelwise_loss = mse_loss(y_pred, y) if half_edge_loss_factor > 0.0: y_coordinates = x[:, 0].long() x_coordinates = x[:, 1].long() x_coords_shifted_left = torch.clamp(x_coordinates - 1, min=0) y_coords_shifted_up = torch.clamp(y_coordinates - 1, min=0) image_indexes = torch.argmax(x[:, 2:], dim=1) x_left_coords = torch.column_stack( (y_coordinates, x_coords_shifted_left)).float() x_left = torch.clone(x) x_left[:, 0:2] = x_left_coords x_up_coords = torch.column_stack( (y_coords_shifted_up, x_coordinates)).float() x_up = torch.clone(x) x_up[:, 0:2] = x_up_coords y_pred_left = self(x_left) y_pred_up = self(x_up) dx_pred = y_pred - y_pred_left dy_pred = y_pred - y_pred_up dx_gt = dx_images[image_indexes, y_coordinates, x_coordinates] dy_gt = dy_images[image_indexes, y_coordinates, x_coordinates] dx_loss = mse_loss(dx_pred.flatten(), dx_gt) dy_loss = mse_loss(dy_pred.flatten(), dy_gt) return (0.5 * pixelwise_loss + half_edge_loss_factor * dx_loss + half_edge_loss_factor * dy_loss) else: return pixelwise_loss
def create_training_database(): min = -10 max = 10 # create distribution of 1000 random pairs in range [-10, 10) pairs = (max - min) * torch.rand(1000, 2) + min l1: list[float] = [pair[0] for pair in pairs] l2: list[float] = [pair[1] for pair in pairs] l1: torch.Tensor = torch.tensor(l1) l2: torch.Tensor = torch.tensor(l2) function_results = torch.sin(l1 + (l2 / numpy.pi)) # 3-dimensional tensor: (l1, l2, result) pairs_with_results = torch.column_stack((pairs, function_results)) torch.save(pairs_with_results, "mydataset.dat")
def generate_vad_segment_table_per_tensor(sequence: torch.Tensor, per_args: Dict[str, float]) -> torch.Tensor: """ See description in generate_overlap_vad_seq. Use this for single instance pipeline. """ shift_length_in_sec = per_args['shift_length_in_sec'] speech_segments = binarization(sequence, per_args) speech_segments = filtering(speech_segments, per_args) if speech_segments.shape == torch.Size([0]): return speech_segments speech_segments, _ = torch.sort(speech_segments, 0) dur = speech_segments[:, 1:2] - speech_segments[:, 0:1] + shift_length_in_sec speech_segments = torch.column_stack((speech_segments, dur)) return speech_segments
def fit(self, A, Y, num_sample, threshold): num_iterations = math.inf iterations_done = 0 num_samples = 3 max_inlier_count = 0 best_model = None probability_outlier = torch.scalar_tensor(0.5, dtype=torch.double) desired_prob = torch.scalar_tensor(0.95, dtype=torch.double) total_data = torch.column_stack((A, Y)) data_size = len(total_data) while num_iterations > iterations_done: random.shuffle(total_data) sample_data = total_data[:num_samples, :] estimated_model = self.curve_fitting_model.fit( sample_data[:, :-1], sample_data[:, -1:]) y_cap = torch.mm(A, estimated_model) error = torch.abs(Y - y_cap.T) inlier_count = torch.count_nonzero(error < threshold) if inlier_count > max_inlier_count: max_inlier_count = inlier_count best_model = estimated_model probability_outlier = 1 - inlier_count / data_size #print('# inliers:', inlier_count) #print('# prob_outlier:', probability_outlier) num_iterations = torch.log(1 - desired_prob) / torch.log( 1 - (1 - probability_outlier)**num_sample) iterations_done = iterations_done + 1 #print('# s:', iterations_done) #print('# n:', num_iterations) #print('# max_inlier_count: ', max_inlier_count) return best_model
import math import torch # distribution of 1000 random points in the domain [-10, 10]^2 maximum_value = 10 minimum_value = -10 input_tensor = (maximum_value - minimum_value) * torch.rand(1000, 2) + minimum_value function_values = [] # value of f for each point for i in range(1000): x1 = input_tensor[i][0] x2 = input_tensor[i][1] value = torch.sin(x1 + x2 / math.pi) function_values.append(value) function_values = torch.tensor(function_values) # create the pairs pairs = torch.column_stack((input_tensor, function_values)) # print(pairs) # save database torch.save(pairs, "mydataset.dat")
def forward(self, screens, states): c = self.conv(screens).view(screens.size()[0], -1) c = torch.column_stack([self.fc1(c), states]) # return self.fc2(c) return c
import torch n = 1000 mini = -10 maxi = 10 random_points = (mini - maxi) * torch.rand(n, 2) + maxi PI = torch.tensor(3.14159265359) points = [] results = [] for point in random_points: x1 = point[0] x2 = point[1] # f_(x1, x2) = sin(x1 + x2/pi) r = torch.sin(torch.addcdiv(x1, x2, PI)) points.append(point) results.append(r) points = torch.stack(points) results = torch.stack(results) database = torch.column_stack((points, results)) # print(database) torch.save(database, "mydataset.dat")
import torch import json import math right, left, size = 10, -10, 1000 randomTensor = (right - left) * torch.rand((size, 2)) + left firstCoordinate = [] secondCoordinate = [] for value in randomTensor: firstCoordinate.append(value[0]) secondCoordinate.append(value[1]) firstCoordinate = torch.tensor(firstCoordinate) secondCoordinate = torch.tensor(secondCoordinate) functionValues = torch.sin(firstCoordinate + (secondCoordinate / math.pi)) dataset = torch.column_stack((randomTensor, functionValues)) print(dataset) torch.save(dataset, "mydataset.dat")
def __createTensor(self): inputTensor = self.__generateInput() outputTensor = self.__computeFunctionValues(inputTensor) pairedTensor = torch.column_stack((inputTensor, outputTensor)) return pairedTensor
def createDistribution(n=1000): points = torch.rand(n, 2) * 20 - 10 results = computeResults(points) return torch.column_stack((points, results))
import torch import numpy as np max_ = 10 min_ = -10 size = 1000 x = (max_ - min_) * torch.rand((size, 2)) + min_ x_0 = torch.tensor([x_[0] for x_ in x]) x_1 = torch.tensor([x_[1] for x_ in x]) y = torch.sin(x_0 + x_1 / np.pi) pairs = torch.column_stack((x, y)) print(x) print(y) print(pairs) torch.save(pairs, 'mydataset.dat')