def init_cent(self, data_array, k): temp_data = data_array.clone() num_point = temp_data.shape[0] num_dim = temp_data.shape[1] centroid = torch.zeros(k, num_dim) cent_idx = Tensor(np.random.choice(range(num_point), 1)).long() centroid[0, :] = temp_data[cent_idx, :] temp_data = temp_data[torch.arange(num_point) != cent_idx] num_point -= 1 for k_i in range(0, k - 1, 1): distance = torch.sqrt( torch.pow( centroid[0:k_i + 1, :].unsqueeze(0).repeat( num_point, 1, 1) - temp_data.unsqueeze(1).repeat(1, k_i + 1, 1), 2).sum(dim=-1)) distance = distance.sum(dim=-1) val, idx = torch.max(distance, dim=0) centroid[k_i + 1, :] = temp_data[idx, :] temp_data = temp_data[torch.arange(num_point) != idx] num_point -= 1 return centroid
def forward(self, x, cf, cc): H = self.s_1(x) H = self.s_1b(H) H = self.s_1a(H) H = self.s_2(H) H = self.s_2b(H) H = self.s_2a(H) H = H.view(x.size(0), -1) if isinstance(cf, Variable): fin_state = torch.cat([cf, cc]) else: fin_state = Variable(Tensor([cf, cc])) fin_state = torch.unsqueeze(fin_state, 0) H = torch.cat([H, fin_state], -1) H = self.d_1(H) H = self.d_1b(H) H = self.d_1a(H) H = self.d_2(H) H = self.d_2b(H) H = self.d_2a(H) H = self.d_f(H) return self.d_fs(H)
def warmup(self): """ Warmup the DND with values from an episode with a random policy """ state = self.env.reset() total_reward = 0 done = False while not done: action = random.randint(0, self.env.action_space.n - 1) next_state, reward, done, _ = self.env.step(action) total_reward += reward self.transition_queue.append(Transition(state, action, reward)) state = next_state for t in range(len(self.transition_queue)): transition = self.transition_queue[t] state = Variable(Tensor(transition.state)).unsqueeze(0) action = transition.action state_embedding = self.embedding_network(move_to_gpu(state)) dnd = self.dnd_list[action] Q_N = move_to_gpu(self.Q_lookahead(t, True)) if dnd.keys_to_be_inserted is None and dnd.keys is None: dnd.insert(state_embedding, Q_N.detach().unsqueeze(0)) else: embedding_index = dnd.get_index(state_embedding) if embedding_index is None: dnd.insert(state_embedding.detach(), Q_N.detach().unsqueeze(0)) else: Q = self.Q_update(dnd.values[embedding_index], Q_N) dnd.update(Q.detach(), embedding_index) self.replay_memory.push(transition.state, action, Q_N) [dnd.commit_insert() for dnd in self.dnd_list] # Clear out transition queue self.transition_queue = [] return total_reward
def get_class_weights(labels: Series) -> Tensor: """ Calculate class weightings based on each class' proportion in the label. :param labels: The labels in the training dataset. :type labels: Series :return: A tensor of weights. :rtype: Tensor """ # Calculate class weightings class_counts = dict(Counter(labels)) m = max(class_counts.values()) for c in class_counts: class_counts[c] = m / class_counts[c] # Convert weightings to tensor weights = [] for k in sorted(class_counts.keys()): weights.append(class_counts[k]) weights = Tensor(weights) # Move weights to GPU if available if cuda.is_available(): weights = weights.cuda() return weights
def program_weights(self, from_reference: bool = True) -> None: """Apply weights noise to the current tile weights and saves these for repeated drift experiments. This method also establishes the drift coefficients for each conductance slice. Args: from_reference: Whether to use weights from reference """ if not from_reference or self.reference_combined_weights is None: self.reference_combined_weights = Tensor( self.tile.get_weights()).to(self.device) self.programmed_weights, self.nu_drift_list = self.noise_model.apply_programming_noise( self.reference_combined_weights) if self.drift_compensation is not None: self.tile.set_weights( self.programmed_weights.detach().cpu().numpy()) forward_output = self._forward_drift_readout_tensor() self.drift_baseline = self.drift_compensation.init_baseline( forward_output)
def __getitem__(self, index): file_path = train[index] img = np.array(Image.open(file_path).convert('RGB').resize([128, 128])) img = Tensor(img).view(3, 128, 128) file_name = ntpath.basename(ntpath.splitext(train[index])[0]) y = 0 age = -1 sex = -1 if melanoma_dict.get(file_name) is not None: y = melanoma_dict.get(file_name)['target'] g = melanoma_dict.get(file_name)['gender'] if g == 'female': g = 0 elif g == 'male': g = 1 else: g = -1 sex = g age = melanoma_dict.get(file_name)['age'] if type(age) == str: age = -80 return [img, y, sex, age]
def forward(self, x): """forward pass of GP model """ year = x.narrow(1,0,1) week = x.narrow(1,1,1) spatial = x.narrow(1,2,2) remote = x.narrow(1,5,1) #social = x.narrow(1,8,1) # prevent period to reset mean = self.mean_module(x).view(-1) #compute covariances self.covar_season.period_length = Tensor([1]) # year seasonality indicating 1 covar_season = self.covar_season(year) covar_week = self.covar_week(week) covar_spatial = self.covar_spatial(spatial) covar_remote = self.covar_remote(remote) #covar_social = self.covar_social(social) covariance = covar_season + covar_remote + covar_spatial\ + covar_week return gpytorch.distributions.MultivariateNormal(mean, covariance)
def __call__(self, probs: Tensor, target: Tensor, _: Tensor) -> Tensor: assert simplex(probs) and simplex(target) pc = probs[:, self.idc, ...].type(torch.float32) tc = target[:, self.idc, ...].type(torch.float32) w: Tensor = 1 / ( (einsum("bcwh->bc", tc).type(torch.float32) + 1e-10)**2) intersection: Tensor = w * einsum("bcwh,bcwh->bc", pc, tc) union: Tensor = w * (einsum("bcwh->bc", pc) + einsum("bcwh->bc", tc)) divided: Tensor = 1 - 2 * (einsum("bc->b", intersection) + 1e-10) / (einsum("bc->b", union) + 1e-10) loss_gde = divided.mean() log_p: Tensor = (probs[:, self.idc, ...] + 1e-10).log() mask_weighted = torch.einsum( "bcwh,c->bcwh", [tc, Tensor(self.weights).to(tc.device)]) loss_ce = -torch.einsum("bcwh,bcwh->", [mask_weighted, log_p]) loss_ce /= tc.sum() + 1e-10 loss = loss_ce + self.lamb * loss_gde return loss
def move(self, vision): vectors: list = [] for cell in self.muscles: vectors.append([i.item() for i in cell.action(vision)]) averaged_direction: Tensor = Tensor(vectors).mean(0).detach() self.vectors = vectors for ind, cell in enumerate(self.muscles): #for neibor in cell.links: # cell.x += vector[0]. if cell.energy <= 0: del self.muscles[ind] continue dx: float = self.vectors[ind][0] dy: float = self.vectors[ind][1] for neibor in cell.links: link_vec: tuple = (cell.x - neibor.x, cell.y - neibor.y) norm_l: float = norm(link_vec) if norm_l == 0: continue proj_len: float = scalar_mul(link_vec, (dx, dy)) projection: tuple = (link_vec[0] * proj_len / norm_l, link_vec[1] * proj_len / norm_l) neibor.x += projection[0] neibor.y += projection[1] cell.x += self.speed * dx cell.y += self.speed * dy #bacward pass cell.brain.backward(averaged_direction)
def test_inertia_2_moves(self, nb, move_at_1, move_at_2, action=2): batch_images = Tensor(nb, self.game.get_screen_channels(), self.game.get_screen_height(), self.game.get_screen_width()) batch_actions = torch.LongTensor(nb) for t in range(300): self.game.make_action(self.actions[3][1]) for t in range(nb): if t == move_at_1 or t == move_at_2: a = action else: a = 3 reward = self.game.make_action(self.actions[a][1]) state = self.game.get_state() if state is None: self.game.new_episode() state = self.game.get_state() frame = torch.from_numpy(state.screen_buffer).float() batch_images[t] = frame batch_actions[t] = a return batch_images, batch_actions
def pathak_generator(self, probs: Tensor, target: Tensor, bounds) -> Tensor: _, w, h = probs.shape # Replace the probabilities with certainty for the few weak labels that we have weak_labels = target[...] weak_labels[self.ignore, ...] = 0 assert not simplex(weak_labels) and simplex(target) lower, upper = bounds[-1] labeled_pixels = weak_labels.any(axis=0) assert w * h == (labeled_pixels.sum() + (~labeled_pixels).sum()) # make sure all pixels are covered scribbled_probs = weak_labels + einsum("cwh,wh->cwh", probs, ~labeled_pixels) assert simplex(scribbled_probs) u: Tensor max_iter: int = 100 lr: float = 0.00005 b: Tensor = Tensor([-lower, upper]) beta: Tensor = torch.zeros(2, torch.float32) f: Tensor = torch.zeros(2, *probs.shape) f[0, ...] = -1 f[1, ...] = 1 for i in range(max_iter): exped = - einsum("i,icwh->cwh", beta, f).exp() u_star = einsum('cwh,cwh->cwh', probs, exped) u_star /= u_star.sum(axis=0) assert simplex(u_star) d_beta = einsum("cwh,icwh->i", u_star, f) - b n_beta = torch.max(torch.zeros_like(beta), beta + lr * d_beta) u = u_star beta = n_beta return probs2one_hot(u)
def get_slice(self, info): ''' return tensor (c, h, w) c: number of windows to use, 1, 3 or 6 ''' # img_file = info['image'] # img_name = img_file.split('.')[0] img_name = info['image'] if self.mode in ['train', 'val']: label = [int(v) for v in info[self.class_name].values] label = Tensor(label) if self.mode == 'train': img = self._load_img_file(img_name) img = self.aug(img) return img, label elif self.mode == 'val': img = self._load_img_file(img_name) img = self.aug(img) return img, label else: img = self._load_img_file(img_name) return img, img_name
def get_Q_vals(self, x, model_type): ''' Returns Q values for all actions in the agents action space for target or prediction model Args: x (np.ndarray): np array with action first then observation ''' if type(x) != Tensor: x = Tensor(x) x = x.to(self.device) q_vals = None if model_type == 'prediction': q_vals = self.prediction_model(x) elif model_type == 'target': q_vals = self.target_model(x) else: print(model_type) raise ValueError( 'Model type must be either "prediction" or "target"') return q_vals
def test_net(self, net): true_labels = [] predicted_labels = [] for datum in self.val_data: batch_eval = np.zeros([ 1, datum['features'].shape[0], datum['features'].shape[1], datum['features'].shape[2] ]) batch_eval[0, :, :, :] = datum['features'] batch_label = np.zeros([1, len(self.CLASS_LABELS)]) batch_label[0, :] = datum['label'] prediction = net.net(Variable(Tensor(batch_eval))).data.numpy() class_pred = np.argmax(prediction) class_truth = datum['label'] true_labels.append(class_truth) predicted_labels.append(class_pred) self.getConfusionMatrixPlot(true_labels, predicted_labels, self.CLASS_LABELS)
def weighted_cross_entropy( prediction: Tensor, target: Tensor, inputs: Tensor, reduction: str = 'mean') -> Union[float, Tensor]: n_classes = prediction.shape[1] # Retrieve nearest points and their calsses _, _, nn_classes = knn.get(inputs.numpy(), exclude_query=True) nn_classes = Tensor(nn_classes) nn_class_entropy = entropy(nn_classes) # Convert target vector into probabilty distribution target = convert_logits_to_class_distribution(target, n_classes) # Apply softmax on model output prediction = logsoftmax(prediction) loss = (-torch.sum(target * prediction, dim=1).reshape(-1, 1) * torch.exp(-nn_class_entropy)) reduction_method = get_reduction_method(reduction) return reduction_method(loss)
def __init__( self, in_channels: Union[int, Tuple[int, int]], out_channels: int, act: Optional[Callable] = Sigmoid(), root_weight: bool = True, bias: bool = True, **kwargs, ): kwargs.setdefault('aggr', 'add') super(ResGatedGraphConv, self).__init__(**kwargs) self.in_channels = in_channels self.out_channels = out_channels self.act = act self.root_weight = root_weight if isinstance(in_channels, int): in_channels = (in_channels, in_channels) self.lin_key = Linear(in_channels[1], out_channels) self.lin_query = Linear(in_channels[0], out_channels) self.lin_value = Linear(in_channels[0], out_channels) if root_weight: self.lin_skip = Linear(in_channels[1], out_channels, bias=False) else: self.register_parameter('lin_skip', None) if bias: self.bias = Parameter(Tensor(out_channels)) else: self.register_parameter('bias', None) self.reset_parameters()
def infer(net, x_validate, y_validate): x_validate = Tensor(x_validate) net.eval() # turn off dropout layer with torch.no_grad(): outputs = net(x_validate) outputs = outputs[:, 0] sz = int(x_validate.shape[0]) y_predict = -np.ones(sz) loss = 0 for i in range(sz): output = outputs[i] labels = y_validate[i] lossRaw = 1. - labels * output lossRaw[lossRaw < 0.] = 0. loss += lossRaw y = output if y > 0.: y_predict[i] = 1. loss /= sz temp = y_predict == y_validate accuracy = (temp.astype(int)).mean() return loss, accuracy
def __init__(self, env_name, num_episodes=10000, alpha=0.9, beta=0.1, gamma=0.9): """ Actor Critic Algorithm using softmax policy :param alpha: learning rate for actor :param beta: learning rate for critic :param gamma: discount rate """ super(ActorCritic, self).__init__(env_name, num_episodes, alpha, gamma, policy="softmax_policy", report_freq=500, beta=beta) self._feature = Tensor(self.action_size, self.obs_size) self.actions = range(self.action_size) self.min_alpha = 0.1 self.min_beta = 0.01 self._state_value_weight = None
def step(self, obs, explore=False): """ Take a step forward in environment for a minibatch of observations Inputs: obs (PyTorch Variable): Observations for this agent explore (boolean): Whether or not to add exploration noise Outputs: action (PyTorch Variable): Actions for this agent """ action = self.policy(obs) if self.discrete_action: if explore: action = gumbel_softmax(action, hard=True) else: action = onehot_from_logits(action) else: # continuous action if explore: action += Variable(Tensor(self.exploration.noise()), requires_grad=False) #print(action,self.exploration.noise(),"noise") action = action.clamp(-1, 1) return action
def log_partition_function(rbm, batch_size, all_confs): '''Computes (via exact brute-force) the logarithm of the partition function of the Ising model defined by the weights of a Restricted Boltzmann Machine Arguments: :param rbm: Restricted Boltzmann Machine model :type rbm: :class:`ebm.models` :param batch_size: amount of samples used in every computation step :type batch_size: int :param all_confs: All possible configurations of the visible neurons of the model :type all_confs: torch.Tensor :returns logZ: torch.Tensor with the logarithm of the partition function ''' all_confs = DataLoader(all_confs.to(rbm.device), batch_size=batch_size) logsumexps = Tensor([]).to(rbm.device) # for batch in tqdm(all_confs, desc='Computing partition function'): for batch in all_confs: logsumexps = cat([logsumexps, logsumexp(rbm.free_energy(batch).neg())]) logZ = logsumexp(logsumexps) gc.collect() return logZ
def predict_on_image(self, image: Union[np.ndarray, Tensor]) -> Tensor: """Predict on a single input.""" self.eval() if image.dtype is np.uint8: # Converts an image with range [0, 255] with to PyTorch Tensor with range [0, 1]. image = self.tensor_transform(image) # Rescale image between 0 and 1. if image.dtype is torch.uint8 or image.dtype is torch.int64: # If the image is an unscaled tensor. image = image.type("torch.FloatTensor") / 255 if not torch.is_tensor(image): image = Tensor(image) # Put the image tensor on the device the model weights are on. image = image.to(self.device) logits = self.forward(image) segmentation_mask = torch.argmax(logits, dim=1) return segmentation_mask
def test_scalar_edge_loss(self): nodes = [Node(), Node(), Node()] edges = [ Edge(nodes[0], nodes[1], Attribute(Tensor([-50.]))), Edge(nodes[1], nodes[0], Attribute(Tensor([-40.]))), Edge(nodes[0], nodes[2], Attribute(Tensor([1.]))) ] g1 = Graph(nodes, edges) g2 = deepcopy(g1) g2.ordered_edges[0].attr.val = Tensor([-45.]) g2.ordered_edges[1].attr.val = Tensor([-40.]) g2.ordered_edges[2].attr.val = Tensor([1.1]) loss = GraphLoss(e_fn=MSELoss()) loss_val = loss(g1, g2).detach().numpy() target_loss_val = ((-50. + 45.)**2 + (-40. + 40.)**2 + (1 - 1.1)**2) / 3 self.assertTrue(np.isclose(loss_val, target_loss_val))
def plot_TestPoints(self,model,file,n=1e5,SurfaceRecievers=False): # ----- Plotting Recovered Velocity Misfit ---- plt.clf() number_random_checks = 1000 # Projecting sample points into LatLong Xp = torch.rand(int(n),6) Xp[:,:3] = Xp[:,:3]*(Tensor(self.xmax)-Tensor(self.xmin))[None,:] + Tensor(self.xmin) Xp[:,3:] = Xp[:,3:]*(Tensor(self.xmax)-Tensor(self.xmin))[None,:] + Tensor(self.xmin) Vp = model.Velocity(Xp) X = np.arange(self.xmin[-1],self.xmax[-1],self.sep) plt.scatter(Xp[:,-1].cpu().numpy(),Vp.cpu().detach().numpy(),0.1,'k',label='RecoveredVelocity',alpha=0.1) plt.plot(X,self.velmod_fnc(X),'g',label='Interpolated Velocity') plt.scatter(self.velmod['Depth'],self.velmod['V'],15,'r',label='Input velocity') plt.ylabel('Velocity km/s') plt.xlabel('Depth') plt.legend() plt.xlim([self.xmin[-1],self.xmax[-1]]) plt.savefig(file)
inh=17.5, nu=[0, 1e-2], norm=78.4) # Specify dataset wrapper environment. environment = DatasetEnvironment(dataset=CIFAR10(path='../../data/CIFAR10'), train=True) # Build pipeline from components. pipeline = Pipeline(network=network, environment=environment, encoding=poisson, time=50, plot_interval=1) # Train the network. labels = environment.labels for i in range(60000): # Choose an output neuron to clamp to spiking behavior. c = choice(10, size=1, replace=False) c = 10 * labels[i].long() + Tensor(c).long() clamp = torch.zeros(pipeline.time, network.n_neurons, dtype=torch.uint8) clamp[:, c] = 1 clamp_v = torch.zeros(pipeline.time, network.n_neurons, dtype=torch.float) clamp_v[:, c] = network.layers['Ae'].thresh + network.layers['Ae'].theta[ c] + 10 # Run a step of the pipeline with clamped neuron. pipeline.step(clamp={'Ae': clamp}, clamp_v={'Ae': clamp_v}) network.reset_()
def init_stable_ss(self, loader, eps=1E-4, init_var=1.2, solver="SCS"): print("RUNNING N4SID for intialization of A, Bu, C, Du") data = [(u, y) for (idx, u, y) in loader] U = data[0][0][0].numpy() Y = data[0][1][0].numpy() sys_id = sippy.system_identification(Y, U, 'N4SID', SS_fixed_order=self.nx) Ass = sys_id.A Bss = sys_id.B Css = sys_id.C Dss = sys_id.D # Sample points, calulate next state samples = 5000 xtild = 3 * np.random.randn(self.nx, samples) utild = 3 * np.random.randn(self.nu, samples) xtild_next = Ass @ xtild + Bss @ utild print("Initializing using LREE") solver_tol = 1E-4 print("Initializing stable LMI ...") # Lip SDP multiplier if self.method == "Layer": multis = cp.Variable((1, 1), 'lambdas', nonneg=True) T = multis * np.eye(self.nw) elif self.method == "Neuron": multis = cp.Variable((self.nw), 'lambdas', nonneg=True) T = cp.diag(multis) elif self.method == "Network": print( 'YOU ARE USING THE NETWORK IQC MULTIPLIER. THIS DOES NOT WORK. PLEASE CHANGE TO NEURON OR LAYER' ) # Variables can be mapped to tril matrix => (n+1) x n // 2 variables multis = cp.Variable((self.nx + 1) * self.nx // 2, 'lambdas', nonneg=True) # Used for mapping vector to tril matrix indices = list(range((self.nx + 1) * self.nx // 2)) Tril_Indices = np.zeros((self.nx, self.nx), dtype=int) Tril_Indices[np.tril_indices(self.nx)] = indices # return the (ii,jj)'th multiplier get_multi = lambda ii, jj: multis[Tril_Indices[ii, jj]] # Get the structured matrix in T Id = np.eye(self.nx) e = lambda ii: Id[:, ii:ii + 1] Tij = lambda ii, jj: e(ii) @ e(ii).T if ii == jj else (e(ii) - e( jj)) @ (e(ii) - e(jj)).T # Construct the full conic comibation of IQC's T = sum( Tij(ii, jj) * get_multi(ii, jj) for ii in range(self.nx) for jj in range(ii + 1)) else: print("Invalid method selected. Try Neuron, Layer or Network") # Construct LMIs P = cp.Variable((self.nx, self.nx), 'P', symmetric=True) E = cp.Variable((self.nx, self.nx), 'E') F = cp.Variable((self.nx, self.nx), 'F') B1 = cp.Variable((self.nx, self.nw), 'Bw') B2 = cp.Variable((self.nx, self.nu), 'Bu') # Randomly initialize C2 C2 = np.random.normal(0, init_var / np.sqrt(self.nw), (self.nw, self.nx)) D22 = np.random.normal(0, init_var / np.sqrt(self.nw), (self.nw, self.nu)) Ctild = T @ C2 Dtild = T @ D22 # Stability LMI S = cp.bmat([[np.zeros((self.nx, self.nx)), Ctild.T], [Ctild, -2 * T]]) z1 = np.zeros((self.nx, self.nw)) z2 = np.zeros((self.nw, self.nw)) Mat11 = cp.bmat([[E + E.T - P, z1], [z1.T, z2]]) - S Mat21 = cp.bmat([[F, B1]]) Mat22 = P Mat = cp.bmat([[Mat11, Mat21.T], [Mat21, Mat22]]) # epsilon ensures strict feasability constraints = [ Mat >> (eps + solver_tol) * np.eye(Mat.shape[0]), P >> (eps + solver_tol) * np.eye(self.nx), E + E.T >> (eps + solver_tol) * np.eye(self.nx), multis >= 1E-6 ] # ensure wide distribution of eigenvalues for Bw bv = self.bv.detach().numpy()[:, None] if type(self.nl) is torch.nn.ReLU: wt = np.maximum(C2 @ xtild + D22 @ utild + bv, 0) else: wt = np.tanh(C2 @ xtild + D22 @ utild + bv) zt = np.concatenate([xtild_next, xtild, wt, utild], 0) EFBB = cp.bmat([[E, -F, -B1, -B2]]) # empirical covariance matrix PHI Phi = zt @ zt.T R = cp.Variable( (2 * self.nx + self.nw + self.nu, 2 * self.nx + self.nw + self.nu)) Q = cp.bmat([[R, EFBB.T], [EFBB, E + E.T - np.eye(self.nx)]]) objective = cp.Minimize(cp.trace(R @ Phi)) constraints.append(Q >> 0) prob = cp.Problem(objective, constraints) if solver == "mosek": prob.solve(solver=cp.MOSEK) else: prob.solve(solver=cp.SCS) print("Initilization Status: ", prob.status) # Solve for output mapping from (W, X, U) -> Y # using linear least squares X = np.zeros((self.nx, U.shape[1])) X[:, 0:1] = sys_id.x0 Einv = np.linalg.inv(E.value) Ahat = Einv @ F.value Bwhat = Einv @ B1.value Buhat = Einv @ B2.value for t in range(1, U.shape[1]): w = np.maximum(C2 @ X[:, t - 1:t] + D22 @ U[:, t - 1:t] + bv, 0) X[:, t:t + 1] = Ahat @ X[:, t - 1:t] + Bwhat @ w + Buhat @ U[:, t - 1:t] if type(self.nl) is torch.nn.ReLU: W = np.maximum(C2 @ X + D22 @ U + bv, 0) else: W = np.tanh(C2 @ X + D22 @ U + bv, 0) Z = np.concatenate([X, W, U], 0) output_mats = Y @ np.linalg.pinv(Z) C1 = output_mats[:, :self.nx] D11 = output_mats[:, self.nx:self.nx + self.nw] D12 = output_mats[:, self.nx + self.nw:] # Assign results to model self.IQC_multipliers = Parameter(Tensor(multis.value)) self.E = Parameter(Tensor(E.value)) self.P = Parameter(Tensor(P.value)) self.F.weight = Parameter(Tensor(F.value)) self.B1.weight = Parameter(Tensor(B1.value)) self.B2.weight = Parameter(Tensor(B2.value)) # Output mappings self.C1.weight = Parameter(Tensor(C1)) self.D12.weight = Parameter(Tensor(D12)) self.D11.weight = Parameter(Tensor(D11)) self.by = Parameter(Tensor([0.0])) # Store Ctild, C2 is extracted from T^{-1} \tilde{C} self.C2tild = Parameter(Tensor(Ctild.value)) self.Dtild = Parameter(Tensor(Dtild.value)) print("Init Complete")
def initialize_stable_LMI(self, eps=1E-4, init_var=1.5, obj='B', solver="SCS"): solver_tol = 1E-4 print("Initializing stable LMI ...") # Lip SDP multiplier if self.method == "Layer": multis = cp.Variable((1, 1), 'lambdas', nonneg=True) T = multis * np.eye(self.nw) elif self.method == "Neuron": multis = cp.Variable((self.nw), 'lambdas', nonneg=True) T = cp.diag(multis) elif self.method == "Network": print( 'YOU ARE USING THE NETWORK IQC MULTIPLIER. THIS DOES NOT WORK. PLEASE CHANGE TO NEURON OR LAYER' ) # Variables can be mapped to tril matrix => (n+1) x n // 2 variables multis = cp.Variable((self.nx + 1) * self.nx // 2, 'lambdas', nonneg=True) # Used for mapping vector to tril matrix indices = list(range((self.nx + 1) * self.nx // 2)) Tril_Indices = np.zeros((self.nx, self.nx), dtype=int) Tril_Indices[np.tril_indices(self.nx)] = indices # return the (ii,jj)'th multiplier get_multi = lambda ii, jj: multis[Tril_Indices[ii, jj]] # Get the structured matrix in T Id = np.eye(self.nx) e = lambda ii: Id[:, ii:ii + 1] Tij = lambda ii, jj: e(ii) @ e(ii).T if ii == jj else (e(ii) - e( jj)) @ (e(ii) - e(jj)).T # Construct the full conic comibation of IQC's T = sum( Tij(ii, jj) * get_multi(ii, jj) for ii in range(self.nx) for jj in range(ii + 1)) else: print("Invalid method selected. Try Neuron, Layer or Network") # Construct LMIs P = cp.Variable((self.nx, self.nx), 'P', symmetric=True) E = cp.Variable((self.nx, self.nx), 'E') F = cp.Variable((self.nx, self.nx), 'F') Bw = cp.Variable((self.nx, self.nw), 'Bw') Cv = np.random.normal(0, init_var / np.sqrt(self.nx), (self.nw, self.nx)) Gamma_v = sp.linalg.block_diag(Cv, np.eye(self.nw)) M = cp.bmat( [[-2 * self.alpha * self.beta * T, (self.alpha + self.beta) * T], [(self.alpha + self.beta) * T, -2 * T]]) # Construct final LMI. z1 = np.zeros((self.nx, self.nw)) z2 = np.zeros((self.nw, self.nw)) Mat11 = cp.bmat([[E + E.T - P, z1], [z1.T, z2] ]) - Gamma_v.T @ M @ Gamma_v Mat21 = cp.bmat([[F, Bw]]) Mat22 = P Mat = cp.bmat([[Mat11, Mat21.T], [Mat21, Mat22]]) # epsilon ensures strict feasability constraints = [ Mat >> (eps + solver_tol) * np.eye(Mat.shape[0]), P >> (eps + solver_tol) * np.eye(self.nx), E + E.T >> (eps + solver_tol) * np.eye(self.nx), multis >= 1E-6 ] A = np.random.normal(0, init_var / np.sqrt(self.nx), (self.nx, self.nw)) # Ass = np.eye(self.nx) # ensure wide distribution of eigenvalues for Bw objective = cp.Minimize(cp.norm(E @ A - Bw)) prob = cp.Problem(objective, constraints) if solver == "mosek": prob.solve(solver=cp.MOSEK) else: prob.solve(solver=cp.SCS) print("Initilization Status: ", prob.status) # self.L_squared = torch.nn.Parameter(torch.Tensor(L_sq.value)) self.IQC_multipliers = Parameter(Tensor(multis.value)) self.E = Parameter(Tensor(E.value)) self.P = Parameter(Tensor(P.value)) self.F.weight = Parameter(Tensor(F.value)) self.Bw.weight = Parameter(Tensor(Bw.value)) self.Bu.weight = Parameter(Tensor(0.1 * self.Bu.weight.data)) self.C.weight = Parameter(Tensor(0.1 * self.C.weight.data)) self.Du.weight = Parameter(Tensor(0.0 * self.Du.weight.data)) self.Ctild = Parameter(Tensor(Cv)) print("Init Complete")
def init_lipschitz_ss(self, loader, gamma=10.0, eps=1E-4, init_var=1.2, solver="SCS"): print("RUNNING N4SID for intialization of A, Bu, C, Du") data = [(u, y) for (idx, u, y) in loader] U = data[0][0][0].numpy() Y = data[0][1][0].numpy() sys_id = sippy.system_identification(Y, U, 'N4SID', SS_fixed_order=self.nx) Ass = sys_id.A Bss = sys_id.B Css = sys_id.C Dss = sys_id.D # Calculate the trajectory. Xtraj = np.zeros((self.nx, Y.shape[1])) for tt in range(1, Y.shape[1]): Xtraj[:, tt:tt + 1] = Ass @ Xtraj[:, tt - 1:tt] + Bss @ U[:, tt - 1:tt] # Sample points, calulate next state samples = 5000 xtild = 3 * np.random.randn(self.nx, samples) utild = 3 * np.random.randn(self.nu, samples) xtild_next = Ass @ xtild + Bss @ utild print("Initializing using LREE") solver_tol = 1E-3 print("Initializing stable LMI ...") # Lip SDP multiplier if self.method == "Layer": multis = cp.Variable((1, 1), 'lambdas', nonneg=True) T = multis * np.eye(self.nw) elif self.method == "Neuron": multis = cp.Variable((self.nw), 'lambdas', nonneg=True) T = cp.diag(multis) elif self.method == "Network": print( 'YOU ARE USING THE NETWORK IQC MULTIPLIER. THIS DOES NOT WORK. PLEASE CHANGE TO NEURON OR LAYER' ) # Variables can be mapped to tril matrix => (n+1) x n // 2 variables multis = cp.Variable((self.nx + 1) * self.nx // 2, 'lambdas', nonneg=True) # Used for mapping vector to tril matrix indices = list(range((self.nx + 1) * self.nx // 2)) Tril_Indices = np.zeros((self.nx, self.nx), dtype=int) Tril_Indices[np.tril_indices(self.nx)] = indices # return the (ii,jj)'th multiplier get_multi = lambda ii, jj: multis[Tril_Indices[ii, jj]] # Get the structured matrix in T Id = np.eye(self.nx) e = lambda ii: Id[:, ii:ii + 1] Tij = lambda ii, jj: e(ii) @ e(ii).T if ii == jj else (e(ii) - e( jj)) @ (e(ii) - e(jj)).T # Construct the full conic comibation of IQC's T = sum( Tij(ii, jj) * get_multi(ii, jj) for ii in range(self.nx) for jj in range(ii + 1)) else: print("Invalid method selected. Try Neuron, Layer or Network") # Construct LMIs P = cp.Variable((self.nx, self.nx), 'P', symmetric=True) E = cp.Variable((self.nx, self.nx), 'E') F = cp.Variable((self.nx, self.nx), 'F') B1 = cp.Variable((self.nx, self.nw), 'Bw') B2 = cp.Variable((self.nx, self.nu), 'Bu') # Output matrices C1 = cp.Variable((self.ny, self.nx), 'C1') D11 = cp.Variable((self.ny, self.nw), 'D11') D12 = cp.Variable((self.ny, self.nu), 'D12') # Randomly initialize C2 C2 = np.random.normal(0, init_var / np.sqrt(self.nw), (self.nw, self.nx)) D22 = np.random.normal(0, init_var / np.sqrt(self.nw), (self.nw, self.nu)) Ctild = T @ C2 Dtild = T @ D22 # lmi for dl2 gain bound. zxu = np.zeros((self.nx, self.nu)) L_sq = gamma**2 # Mat11 = utils.bmat([E + E.T - P, z1, L_sq * np.eye(self.nu)]) - Gamma_v.T @ M @ Gamma_v Mat11 = cp.bmat([[E + E.T - P, -self.beta * Ctild.T, zxu], [-self.beta * Ctild, 2 * T, -self.beta * Dtild], [zxu.T, -self.beta * Dtild.T, L_sq * np.eye(self.nu)]]) Mat21 = cp.bmat([[F, B1, B2], [C1, D11, D12]]) Mat22 = cp.bmat([[P, np.zeros((self.nx, self.ny))], [np.zeros((self.ny, self.nx)), np.eye(self.ny)]]) Mat = cp.bmat([[Mat11, Mat21.T], [Mat21, Mat22]]) # epsilon ensures strict feasability constraints = [ Mat >> solver_tol * np.eye(Mat.shape[0]), P >> (eps + solver_tol) * np.eye(self.nx), E + E.T >> (eps + solver_tol) * np.eye(self.nx), multis >= 1E-6 ] # Find the closest l2 gain bounded model bv = self.bv.detach().numpy()[:, None] if type(self.nl) is torch.nn.ReLU: wt = np.maximum(C2 @ xtild + D22 @ utild + bv, 0) wtraj = np.maximum(C2 @ Xtraj + D22 @ U + bv, 0) else: wt = np.tanh(C2 @ xtild + D22 @ utild + bv) wtraj = np.tanh(C2 @ Xtraj + D22 @ U + bv, 0) zt = np.concatenate([xtild_next, xtild, wt, utild], 0) EFBB = cp.bmat([[E, -F, -B1, -B2]]) # empirical covariance matrix PHI Phi = zt @ zt.T R = cp.Variable( (2 * self.nx + self.nw + self.nu, 2 * self.nx + self.nw + self.nu)) Q = cp.bmat([[R, EFBB.T], [EFBB, E + E.T - np.eye(self.nx)]]) # Add additional term for output errors eta = Y - C1 @ Xtraj - D11 @ wtraj - D12 @ U objective = cp.Minimize(cp.trace(R @ Phi) + cp.norm(eta, p="fro")**2) constraints.append(Q >> 0) prob = cp.Problem(objective, constraints) if solver == "mosek": prob.solve(solver=cp.MOSEK) else: prob.solve(solver=cp.SCS) print("Initilization Status: ", prob.status) # Assign results to model self.IQC_multipliers = Parameter(Tensor(multis.value)) self.E = Parameter(Tensor(E.value)) self.P = Parameter(Tensor(P.value)) self.F.weight = Parameter(Tensor(F.value)) self.B1.weight = Parameter(Tensor(B1.value)) self.B2.weight = Parameter(Tensor(B2.value)) # Output mappings self.C1.weight = Parameter(Tensor(C1.value)) self.D12.weight = Parameter(Tensor(D12.value)) self.D11.weight = Parameter(Tensor(D11.value)) self.by = Parameter(Tensor([0.0])) # Store Ctild and Dtild, C2 and D22 are extracted from # T^{-1} \tilde{C} and T^{-1} \tilde{Dtild} self.C2tild = Parameter(Tensor(Ctild.value)) self.Dtild = Parameter(Tensor(Dtild.value)) print("Init Complete")
def initialize_lipschitz_LMI(self, gamma=10.0, eps=1E-4, init_var=1.5, solver="SCS"): solver_tol = 1E-4 print("Initializing Lipschitz LMI ...") # Lip SDP multiplier if self.method == "Layer": multis = cp.Variable((1), 'lambdas', nonneg=True) T = multis * np.eye(self.nx) elif self.method == "Neuron": multis = cp.Variable((self.nx), 'lambdas', nonneg=True) T = cp.diag(multis) elif self.method == "Network": # Variables can be mapped to tril matrix => (n+1) x n // 2 variables multis = cp.Variable((self.nx + 1) * self.nx // 2, 'lambdas', nonneg=True) # return the (ii,jj)'th multiplier get_multi = lambda ii, jj: multis[(ii * (ii + 1)) // 2 + jj] # Get the structured matrix in T Id = np.eye(self.nx) e = lambda ii: Id[:, ii:ii + 1] Tij = lambda ii, jj: e(ii) @ e(ii).T if ii == jj else (e(ii) - e( jj)) @ (e(ii) - e(jj)).T # Construct the full conic comibation of IQC's T = sum( Tij(ii, jj) * get_multi(ii, jj) for ii in range(0, self.nx) for jj in range(0, ii + 1)) else: print("Invalid method selected. Try Neuron, Layer or Network") # square of L2 gain # L_sq = cp.Variable((1, 1), "rho") L_sq = gamma**2 # Construct LMIs P = cp.Variable((self.nx, self.nx), 'P', symmetric=True) E = cp.Variable((self.nx, self.nx), 'E') F = cp.Variable((self.nx, self.nx), 'F') Bu = cp.Variable((self.nx, self.nu), 'Bu') C = cp.Variable((self.ny, self.nx), 'C') Dw = cp.Variable((self.ny, self.nx), 'Dw') Du = cp.Variable((self.ny, self.nu), 'Du') Bw = cp.Variable((self.nx, self.nw), 'Bw') Cv = np.random.normal(0, init_var / np.sqrt(self.nx), (self.nw, self.nx)) Gamma_1 = sp.linalg.block_diag(Cv, np.eye(self.nw)) Gamma_v = np.concatenate( [Gamma_1, np.zeros((2 * self.nw, self.nu))], axis=1) M = cp.bmat( [[-2 * self.alpha * self.beta * T, (self.alpha + self.beta) * T], [(self.alpha + self.beta) * T.T, -2 * T]]) # Construct final LMI. zxw = np.zeros((self.nx, self.nw)) zxu = np.zeros((self.nx, self.nu)) zwu = np.zeros((self.nw, self.nu)) zww = np.zeros((self.nw, self.nw)) # Mat11 = utils.bmat([E + E.T - P, z1, L_sq * np.eye(self.nu)]) - Gamma_v.T @ M @ Gamma_v Mat11 = cp.bmat([[E + E.T - P, zxw, zxu], [zxw.T, zww, zwu], [zxu.T, zwu.T, L_sq * np.eye(self.nu)] ]) - Gamma_v.T @ M @ Gamma_v Mat21 = cp.bmat([[F, Bw, Bu], [C, Dw, Du]]) Mat22 = cp.bmat([[P, np.zeros((self.nx, self.ny))], [np.zeros((self.ny, self.nx)), np.eye(self.ny)]]) Mat = cp.bmat([[Mat11, Mat21.T], [Mat21, Mat22]]) # epsilon ensures strict feasability constraints = [ Mat >> solver_tol * np.eye(Mat.shape[0]), P >> (eps + solver_tol) * np.eye(self.nx), E + E.T >> (eps + solver_tol) * np.eye(self.nx), multis >= 1E-6 ] # Just find a feasible point A = np.random.normal(0, init_var / np.sqrt(self.nx), (self.nx, self.nx)) # Just find a feasible point objective = cp.Minimize(cp.norm(E @ A - Bw)) prob = cp.Problem(objective, constraints) if solver == "mosek": prob.solve(solver=cp.MOSEK) elif solver == "SCS": prob.solve(solver=cp.SCS) else: print("Select valid sovler") print("Initilization Status: ", prob.status) # self.L_squared = torch.nn.Parameter(torch.Tensor(L_sq.value)) self.IQC_multipliers = Parameter(Tensor(multis.value)) self.E = Parameter(Tensor(E.value)) self.P = Parameter(Tensor(P.value)) self.F.weight = Parameter(Tensor(F.value)) self.Bw.weight = Parameter(Tensor(Bw.value)) self.Bu.weight = Parameter(Tensor(Bu.value)) self.C.weight = Parameter(Tensor(C.value)) self.Dw.weight = Parameter(Tensor(Dw.value)) self.Du.weight = Parameter(Tensor(Du.value)) self.Cv.weight = Parameter(Tensor(Cv))
def __getitem__(self, idx): # read image img_name_a = os.path.join(self.training_image_path, self.img_a_names[idx]) img_name_b = os.path.join(self.training_image_path, self.img_b_names[idx]) image_a = cv2.imread(img_name_a, cv2.IMREAD_COLOR) image_b = cv2.imread(img_name_b, cv2.IMREAD_COLOR) vertices = ast.literal_eval(self.img_a_vertices[idx]) # read theta theta = self.theta_array[idx, :] if self.geometric_model == 'affine': # reshape theta to 2x3 matrix [A|t] where # first row corresponds to X and second to Y theta = theta[[3, 2, 5, 1, 0, 4]].reshape(2, 3) elif self.geometric_model == 'tps': theta = np.expand_dims(np.expand_dims(theta, 1), 2) # hold in the image_a only the crop but maintaining resolution # we achieve this by blanking each pixel outside the vertices image_a = blank_outside_verts(image_a, vertices) # make arrays float tensor for subsequent processing image_a = Tensor(image_a.astype(np.float32)) image_b = Tensor(image_b.astype(np.float32)) theta = Tensor(theta.astype(np.float32)) # permute order of image to CHW image_a = image_a.transpose(1, 2).transpose(0, 1) image_b = image_b.transpose(1, 2).transpose(0, 1) # Resize image using bilinear sampling with identity affine tnf if image_a.size()[0] != self.out_h or image_a.size()[1] != self.out_w: image_a = self.affineTnf( Variable(image_a.unsqueeze(0), requires_grad=False)).data.squeeze(0) # Resize image using bilinear sampling with identity affine tnf if image_b.size()[0] != self.out_h or image_b.size()[1] != self.out_w: image_b = self.affineTnf( Variable(image_b.unsqueeze(0), requires_grad=False)).data.squeeze(0) # if self.mode == 'test': sample = { 'image_a': image_a, 'vertices_a': Tensor(vertices), 'image_b': image_b, 'theta': theta } if self.transform: sample = self.transform(sample) return sample
image = discriminator(image.cuda()) plotter.plotImage(image[0]) plotter.plotImage(image[1]) noise = noiseGenerator.generate(batchSize, channels, (noiseHeight, noiseWidth)) generatedImage = generator(noise) plotter.plotImage(generatedImage) plotter.plotImage(discriminator(generatedImage)[0]) #%% if (training_mode): discriminatorLossesAveragesArray = [] generatorLossesAveragesArray = [] tensorReal = Tensor(full((batchSize, 1), fill_value=1, dtype=f32)).cuda() tensorFake = Tensor(full((batchSize, 1), fill_value=0, dtype=f32)).cuda() #%% noise = noiseGenerator.generate(batchSize, channels, (noiseHeight, noiseWidth)) print(generator(noise).size()) plt.imshow(t.ToPILImage()(generator(noise)[0].cpu().detach())) #%% print(len(training_loader)) #%% tempDiscriminatorRatio = discriminatorIterationsRatio tempGeneratorRatio = generatorIterationsRatio #%%