def __init__(self, init_joints_idxs, trans_estimation=None, reduction='sum', data_weight=1.0, depth_loss_weight=1e2, dtype=torch.float32, **kwargs): super(SMPLifyCameraInitLoss, self).__init__() self.dtype = dtype if trans_estimation is not None: self.register_buffer( 'trans_estimation', utils.to_tensor(trans_estimation, dtype=dtype)) else: self.trans_estimation = trans_estimation self.register_buffer('data_weight', torch.tensor(data_weight, dtype=dtype)) self.register_buffer( 'init_joints_idxs', utils.to_tensor(init_joints_idxs, dtype=torch.long)) self.register_buffer('depth_loss_weight', torch.tensor(depth_loss_weight, dtype=dtype))
def rollout(policy, env, timestep_limit=None, add_noise=False): total_reward = 0.0 state = env.reset() state = utils.to_tensor(state).unsqueeze(0) if self.args.is_cuda: state = state.cuda() done = False while not done: if store_transition: self.num_frames += 1 self.gen_frames += 1 if render and is_render: self.env.render() # print(state) # exit(0) action = self.pop.forward(state) action.clamp(-1, 1) action = utils.to_numpy(action.cpu()) if is_action_noise: action += self.ounoise.noise() # print("come there in evaluate") next_state, reward, done, info = self.env.step( action.flatten()) # Simulate one step in environment # print("come there in evaluate") next_state = utils.to_tensor(next_state).unsqueeze(0) if self.args.is_cuda: next_state = next_state.cuda() total_reward += reward if store_transition: self.add_experience(state, action, next_state, reward, done) state = next_state if store_transition: self.num_games += 1 # print("come here,total_reward:",total_reward) return total_reward
def update_policy(self): state_batch, action_batch, reward_batch, next_state_batch, terminal_batch = self.memory.sample_batch(self.batch_size) state = to_tensor(np.array(state_batch), device=device) action = to_tensor(np.array(action_batch), device=device) next_state = to_tensor(np.array(next_state_batch), device=device) # compute target Q value next_q_value = self.critic_target([next_state, self.actor_target(next_state)]) target_q_value = to_tensor(reward_batch, device=device) \ + self.discount * to_tensor((1 - terminal_batch.astype(np.float)), device=device) * next_q_value # Critic and Actor update self.critic.zero_grad() with torch.set_grad_enabled(True): q_values = self.critic([state, action]) critic_loss = criterion(q_values, target_q_value.detach()) critic_loss.backward() self.critic_optim.step() self.actor.zero_grad() with torch.set_grad_enabled(True): policy_loss = -self.critic([state.detach(), self.actor(state)]).mean() policy_loss.backward() self.actor_optim.step() # Target update soft_update(self.actor_target, self.actor, self.tau) soft_update(self.critic_target, self.critic, self.tau) return to_numpy(-policy_loss), to_numpy(critic_loss), to_numpy(q_values.mean())
def __init__(self, C=10, H=128, W=128, sampling='S', dtype=torch.cuda.FloatTensor): super(OperatorBatch, self).__init__() self.C, self.H, self.W, self.dtype = C, H, W, dtype # subspace dimension reduction pca_dic_data = scio.loadmat( './matfile/pytorch_Ramp2D_200reps_guido_trainingset.mat') self.V = to_tensor(pca_dic_data['V']) self.V_conj = to_tensor(pca_dic_data['V_conj']) if dtype is not None: self.V, self.V_conj = self.V.type(dtype), self.V_conj.type(dtype) assert self.V.shape[1] == self.C, 'Channels Error!' # init mask mask_data = scio.loadmat('./matfile/train_dataXS11_s.mat') if sampling == 'C': mask = mask_data['samplemask_s'] if sampling == 'S': mask = mask_data['samplemask_s'] self.mask = np.squeeze(np.asarray(mask - 1)) print('mask.shape', self.mask.shape)
def critic_loss(model, model_prime, data_batch, args): obs, options, rewards, next_obs, dones = data_batch batch_idx = torch.arange(len(options)).long() options = torch.LongTensor(options).to(model.device) rewards = torch.FloatTensor(rewards).to(model.device) masks = 1 - torch.FloatTensor(dones).to(model.device) # The loss is the TD loss of Q and the update target, so we need to calculate Q states = model.get_state(to_tensor(obs)).squeeze(0) Q = model.get_Q(states) # the update target contains Q_next, but for stable learning we use prime network for this next_states_prime = model_prime.get_state(to_tensor(next_obs)).squeeze(0) next_Q_prime = model_prime.get_Q(next_states_prime) # detach? # Additionally, we need the beta probabilities of the next state next_states = model.get_state(to_tensor(next_obs)).squeeze(0) next_termination_probs = model.get_terminations(next_states).detach() next_options_term_prob = next_termination_probs[batch_idx, options] # Now we can calculate the update target gt gt = rewards + masks * args.gamma * \ ((1 - next_options_term_prob) * next_Q_prime[batch_idx, options] + next_options_term_prob * next_Q_prime.max(dim=-1)[0]) # to update Q we want to use the actual network, not the prime td_err = (Q[batch_idx, options] - gt.detach()).pow(2).mul(0.5).mean() return td_err
def test_goal2(self): """ This method tests goal 2 i.e. whether f(x, z) is monotonically increasing in z for any given x. """ x_goal = to_tensor( self.x_test[np.random.choice(self.x_test.shape[0], 10)], self.device) # x_goal = to_tensor( # sample_random(self.x_range_test, 10, self.x_space_size), self.device, # ) z_goal = torch.sort( to_tensor(sample_random(self.z_range, 15, self.z_space_size), self.device), dim=0, )[0] # Get the z-sample predictions for every test data point. y_predict_mat = self.model.get_z_sample_preds( x_pt=x_goal, z_samples=z_goal, ) y_predict_mat_d = y_predict_mat.cpu().detach().numpy() ascending = np.all(y_predict_mat_d[:-1] <= y_predict_mat_d[1:]) return ascending
def actor_loss(obs, option, logp, entropy, reward, done, next_obs, model, model_prime, args): state = model.get_state(to_tensor(obs)) next_state = model.get_state(to_tensor(next_obs)) next_state_prime = model_prime.get_state(to_tensor(next_obs)) option_term_prob = model.get_terminations(state)[:, option] next_option_term_prob = model.get_terminations( next_state)[:, option].detach() Q = model.get_Q(state).detach().squeeze() next_Q_prime = model_prime.get_Q(next_state_prime).detach().squeeze() # Target update gt gt = reward + (1 - done) * args.gamma * \ ((1 - next_option_term_prob) * next_Q_prime[option] + next_option_term_prob * next_Q_prime.max(dim=-1)[0]) pdb.set_trace() # The termination loss termination_loss = option_term_prob * (Q[option].detach() - Q.max( dim=-1)[0].detach() + args.termination_reg) * (1 - done) # actor-critic policy gradient with entropy regularization policy_loss = -logp * (gt.detach() - Q[option]) - args.entropy_reg * entropy actor_loss = termination_loss + policy_loss return actor_loss
def synthesize(model, gan_type, code): """Synthesizes an image with the give code.""" if gan_type == 'pggan': image = model(to_tensor(code))['image'] elif gan_type in ['stylegan', 'stylegan2']: image = model.synthesis(to_tensor(code))['image'] image = postprocess(image)[0] return image
def __init__(self, states: np.ndarray, actions: np.ndarray, old_log_probs: np.ndarray, rewards: np.ndarray): self.states = states self.actions = actions self.old_log_probs = old_log_probs self.rewards = rewards self.states_t = to_tensor(self.states) self.actions_t = to_tensor(self.actions) self.old_log_probs_t = to_tensor(self.old_log_probs) self.rewards_t = to_tensor(self.rewards)
def train(self): self.epi_rewards = [] self.epi_losses = [] for epi in range(self.conf['num_episode']): # episodes print("--- episode %s ---"%(epi)) epi_reward = 0.0 state = self.env.reset() # [2*num_plant, 1] state_ts = to_tensor(state).unsqueeze(0) # [1, 2*num_plant, 1] # unsqueeze(0) on 'state' is necessary for reply memory dataPlot = dataPlotter_v2(self.conf) t = P.t_start while t < P.t_end: # one episode (simulation) t_next_plot = t + P.t_plot while t < t_next_plot: # data plot period if round(t,3)*1000 % 10 == 0: # every 10 ms, schedule udpate action = self.agent.select_action(state_ts) # action type: tensor [1X1] next_state, reward, done, info = self.env.step(action.item(), t) # shape of next_state : [(2*num_plant) X 1] epi_reward += reward # self.env.step(0, t) # test for env.step() function if done: next_state_ts = None break else: next_state_ts = to_tensor(next_state).unsqueeze(0) # [1, 2*num_plant, 1] reward_ts = to_tensor(np.asarray(reward).reshape(-1)) # it's size should be [1] for reply buffer # memory push self.memory.push_transition(state_ts, action, next_state_ts, reward_ts) state_ts = next_state_ts # model optimization step currLoss = self.agent.optimization_model(self.memory) else: # every 1 ms self.env.update_plant_state(t) # plant status update t = t + P.Ts # self.update_dataPlot(dataPlot, t) # update data plot if next_state_ts == None: # episode terminates dataPlot.close() break # episode done self.epi_rewards.append(epi_reward) self.epi_losses.append(currLoss) # The target network has its weights kept frozen most of the time if epi % self.conf['target_update'] == 0: self.agent.scheduler_target.load_state_dict(self.agent.scheduler.state_dict()) # Save satet_dict torch.save(self.agent.scheduler.state_dict(), MODEL_PATH) self.save_log() self.load_log()
def __init__(self, z_samples, datasets, device): self.less_than_ratios = z_samples.less_than_ratios self.y_test = datasets.y_test self.x_test = datasets.x_test self.y_test_pt = to_tensor(datasets.y_test, device) self.x_test_pt = to_tensor(datasets.x_test, device) self.x_orderings_pt = [ torch.sort(self.x_test_pt[:, i])[1] for i in range(self.x_test_pt.shape[1]) ]
def _compute_advantage_estimates(self, trajectories): states = [] actions = [] returns = [] log_probs = [] advantages = [] for traj in trajectories: advantage = 0 return_ = traj[-1].value for i in reversed(range(len(traj) - 1)): exp = traj[i] reward = np.asarray([exp.reward]) done = np.asarray([exp.done]) return_ = reward + self._gamma * (1 - done) * return_ next_value = traj[i + 1].value # Generalized Advantage Estimation # δᵗ = rᵗ + γ * V(sᵗ⁺ⁱ) − V(sᵗ) # Â(∞)= ∑ γˡ * δᵗ delta = reward + self._gamma * (1 - done) * next_value - exp.value advantage = advantage * (self._gae_lambda * self._gamma) * (1 - done) + delta states.append(exp.state) actions.append(exp.action) returns.append(return_) log_probs.append(exp.log_prob) advantages.append(advantage) # Required only for debugging states = list(reversed(states)) actions = list(reversed(actions)) returns = list(reversed(returns)) log_probs = list(reversed(log_probs)) advantages = list(reversed(advantages)) states = to_tensor(states) actions = to_tensor(actions) returns = to_tensor(returns) log_probs = to_tensor(log_probs) advantages = to_tensor(advantages) # Normalize the advantages advantages = (advantages - torch.mean(advantages)) / torch.std(advantages) return states, actions, returns, log_probs, advantages
def main(): global words global word2idx test_file = restaurant_test_file # Load Model path = "Saved_Models/PD8/10epoch_5" model = torch.load(path) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) print("\nTest Set :") #test_vocab = file_stats(test_file, test_file=True) with open("test_pd_data.pickle", "rb") as f: test_vocab = pickle.load(f) file_stats(test_vocab, return_vocab=False) words, word2idx = create_word_vocab(test_vocab, words, word2idx) weights_matrix = create_weights(words, word2idx) test_vocab = to_tensor(test_vocab, word2idx) test_set = vocabDataset(test_vocab) test_batch = DataLoader(test_set, batch_size=32, shuffle=True) acc, cm = model.test(test_batch, weights_matrix) print(cm) print(f'Test Acc: {acc*100:.2f}%')
def optimize_style(source_image, model, model_name, gan_type, dlatent, iteration): resolution = parse_resolution(model_name) img = image_reader(source_image, resize=resolution) # (1,3,1024,1024) -1~1 img = img.to(device) MSE_Loss = nn.MSELoss(reduction="mean") img_p = img.clone() # Perceptual loss 用画像 upsample2d = torch.nn.Upsample(scale_factor=256 / resolution, mode="bilinear") # VGG入力のため(256,256)にリサイズ img_p = upsample2d(img_p) perceptual_net = VGG16_for_Perceptual(n_layers=[2, 4, 14, 21]).to(device) w = to_tensor(dlatent).requires_grad_() optimizer = optim.Adam({w}, lr=0.01, betas=(0.9, 0.999), eps=1e-8) for i in progress_bar(range(iteration)): optimizer.zero_grad() synth_img = forward(model, gan_type, w) synth_img = (synth_img + 1.0) / 2.0 mse_loss, perceptual_loss = caluclate_loss(synth_img, img, perceptual_net, img_p, MSE_Loss, upsample2d) loss = mse_loss + perceptual_loss loss.backward() optimizer.step() return w.detach().cpu().numpy()
def forward(self, x): if isinstance(x, tuple): im, gt = x else: im = x gt = None assert im.size(0) == 1, 'only single element batches supported' feats = self.features(to_tensor(im)) roi_boxes, rpn_prob, rpn_loss = self.rpn(im, feats, gt) if gt is not None: # append gt boxes and sample fg / bg boxes # proposal_target-layer.py all_rois, frcnn_labels, roi_boxes, frcnn_bbox_targets = self.frcnn_targets( roi_boxes, im, gt) # r-cnn regions = self.roi_pooling(feats, roi_boxes) scores, bbox_pred = self.classifier(regions) boxes = self.bbox_reg(roi_boxes, bbox_pred, im) # apply cls + bbox reg loss here if gt is not None: frcnn_loss = self.frcnn_loss(scores, bbox_pred, frcnn_labels, frcnn_bbox_targets) loss = frcnn_loss + rpn_loss return loss, scores, boxes return scores, boxes
def __init__(self, args): super().__init__() self.lr = args.learning_rate self.z_dim = 100 self.eval_interval = 100 self.eval_size = 16 self.data_dir = args.data_dir self.device = "cpu" if args.no_cuda else "cuda" # evaluate generator based pn fixed noise during training self.fixed_z = to_tensor( np.random.normal(0, 1, size=(self.eval_size, self.z_dim)), False).to(self.device) self.label_smooth = args.label_smooth self.G_loss = [] self.D_loss = [] self.path = args.path self.batch_size = args.batch_size self.checkpoint_path = os.path.join(self.path, "checkpoint") self.images_path = os.path.join(self.path, "images") self.train_images_path = os.path.join(self.images_path, "train_images") self.val_images_path = os.path.join(self.images_path, "val_images") make_dirs(self.checkpoint_path, self.train_images_path, self.val_images_path)
def predict(self, x): #self.load_model('nn_model.chp') x = x.to_numpy() x_tensor = to_tensor(x) ypred = self.model(x_tensor) ypred = to_numpy(ypred) return ypred.reshape(-1)
def run_cmu_test_instance(model, HouseImg, HouseData, idx, sep, use_cuda=True): NofNodes = 30 PT1 = np.copy(HouseData[idx]).astype(np.float32) PT2 = np.copy(HouseData[idx + sep]).astype(np.float32) gTruth = np.random.permutation(NofNodes) PT1 = PT1[gTruth, :] pt1 = pc_normalize(PT1) pt2 = pc_normalize(PT2) pt1 = rotate_pt(pt1) nn_idx1 = knn(pt1, 8) nn_idx2 = knn(pt2, 8) mask = np.asarray([1.0] * pt1.shape[0]).astype(np.float32) with torch.no_grad(): pt1, pt2, nn_idx1, nn_idx2, mask = to_tensor( [pt1, pt2, nn_idx1, nn_idx2, mask], use_cuda) feature1 = model(pt1.permute(0, 2, 1), nn_idx1.contiguous(), mask) feature2 = model(pt2.permute(0, 2, 1), nn_idx2.contiguous(), mask) sim = torch.bmm(feature1.permute(0, 2, 1), feature2) cost = -sim[0].cpu().numpy() row_ind, col_ind = linear_sum_assignment(cost) acc = ComputeAccuracyPas(col_ind, gTruth, NofNodes) return acc
def quantify_model(self): modules = list(self.model.named_modules()) for i, ind in enumerate(self.compressible_idx): layer_name = modules[ind][0] layer = modules[ind][1] for name, param in layer.named_parameters(): param_name = '{}.{}_{}bit'.format(layer_name, name, self.strategy_bits[i]) # self.log_writer.write(param_name + '\n') # self.log_writer.flush() if not self.compressed_params.__contains__( param_name): # quantify parameters num = 2**self.strategy_bits[i] # if not type(num) == int: # print("num is not integer") # print(type(num)) if self.quantify_kind == 'linear': min = param.data.min() unit = (param.data.max() - min) / num index = (param.data - min) / unit index = index.int() index[index == num] -= 1 else: tmp_param = param.data.view(-1) if num >= len(tmp_param): # do nothing index = to_tensor(np.array(range( len(tmp_param)))).int() index = index.view(param.data.shape) else: # k-means estimator = KMeans(n_clusters=num) estimator.fit(tmp_param.reshape(-1, 1).cpu()) index = torch.Tensor(estimator.labels_).int() index = index.view(param.data.shape) center = [ param.data[index == i].mean().item() for i in range(num) ] self.compressed_params[param_name + 'c'] = to_tensor(center) self.compressed_params[param_name + 'i'] = index idx = self.compressed_params[param_name + 'i'].long() param.data.copy_(self.compressed_params[param_name + 'c'][idx])
def episode_init(self, state): state = utils.to_tensor(state).view((1, ) + state.shape) action = self.policy(state) self.next_action = action self.next_state = state return action.cpu().numpy()
def __getitem__(self, index): """ returns one Phoneme (1, 1, 40, #f """ article_torch = utils.to_tensor((X_data[index])) dict_ = {'article': article_torch} return dict_
def update_end(self, reward): current_action = self.next_action current_state = self.next_state current_state_value = self.critic.estimate_state(current_state) td_target = utils.to_tensor([[float(reward)]]) td_error = td_target - current_state_value self.actor.update(current_state, current_action, td_error) self.critic.update(current_state_value, td_target)
def select_action(self, state, apply_noise=False): self.eval() action = to_numpy(self.actor(to_tensor(np.array([state]), device=device))).squeeze(0) self.train() if apply_noise: action = action + self.noise.sample() action = np.clip(action, -1., 1.) self.last_action = action #print('action:', action, 'output:', action.argmax()) return action.argmax() if self.discrete else action
def update(self, state, reward, done): state = utils.to_tensor(state).view((1, ) + state.shape) next_action = -1 if not done: next_action = self.update_step(state, reward) if done: self.update_end(reward) return next_action
def main(): runs = 8 # ds = RandomDataset() # ds = ImageDataset() ds = TextDataset() # ds = RecommendationDataset() k = ds.k() objs = [0] * 5 times = [0] * 5 names = [None] * 5 for run in range(runs): step = ds.step(run) # M = torch.from_numpy(ds.generate(run)).float().to(device) M, E = ds.generate(run) M = utils.to_tensor(M) E = utils.to_tensor(E) # M = ds.generate(run) print(M.shape) algorithms: List[Optimizer] = [ SPGD(M, k, step, True, 0.1), MultUpdate(M, k), BlockCoordinate(M, k, step, False), AO_ADMM(M, k), LeastSquares(M, k) ] for i, opt in enumerate(algorithms): print(opt.name()) names[i] = opt.name() start_time = time.time() W, H = opt.optimize(E, ds.iterations()) print() objs[i] += utils.objective(M, W, H, E) elapsed = time.time() - start_time times[i] += elapsed print("time", elapsed) ds.postprocess(W, H, run, opt.short_name()) print(names) print(objs) print(times)
def __getitem__(self, idx): # image = utils.load_image(self.images[idx]) image = self.images[idx] label = utils.to_tensor(self.labels[idx], torch.long) if self.transforms is not None: t_image = self.transforms(image) image = resize_transform(image) return t_image, label, np.array(image)
def predict_action(self, state): # return an action action_values = self(state) actions_chosen = list() for idx in range(0, self.action_dim * 3, self.action_dim): probabilities = self.softmax_dim_0(action_values[idx:idx + self.action_dim]) dis = torch.distributions.Categorical(probs=probabilities) actions_chosen.append(dis.sample()) return utils.to_tensor(actions_chosen).long()
def select_action(self, state): action_prob = to_numpy(self.actor(to_tensor(state.reshape( 1, -1)))).squeeze(0) dice = stats.rv_discrete( values=(range(self.action_start, self.action_end + 1), action_prob)) action = dice.rvs(size=1) # print(action_prob) # print('select action: {}'.format(action[0])) return action[0]
def feature_extraction(self, x: List[List]): # Batch_iter sorts the sentences. sents_tensor = to_tensor(x, device=self.device) # (bs, max_seq_len) seq_lengths = torch.tensor([len(sent) for sent in x]) masks = generate_sent_masks(sents_tensor, seq_lengths).to(self.device) x = self.embedding(sents_tensor) x = self.dropout(x) x = pack_padded_sequence(x, lengths=seq_lengths, batch_first=True) x, _ = self.lstm(x) x, _ = pad_packed_sequence(x, batch_first=True) return x, masks
def update_policy(self): # Sample batch state_batch, action_batch, reward_batch, \ next_state_batch, terminal_batch = self.memory.sample_and_split(self.batch_size) # normalize the reward batch_mean_reward = np.mean(reward_batch) if self.moving_average is None: self.moving_average = batch_mean_reward else: self.moving_average += self.moving_alpha * (batch_mean_reward - self.moving_average) reward_batch -= self.moving_average # if reward_batch.std() > 0: # reward_batch /= reward_batch.std() # Prepare for the target q batch with torch.no_grad(): next_q_values = self.critic_target([ to_tensor(next_state_batch), self.actor_target(to_tensor(next_state_batch)), ]) target_q_batch = to_tensor(reward_batch) + \ self.discount * to_tensor(terminal_batch.astype(np.float)) * next_q_values # Critic update self.critic.zero_grad() q_batch = self.critic( [to_tensor(state_batch), to_tensor(action_batch)]) value_loss = criterion(q_batch, target_q_batch) value_loss.backward() self.critic_optim.step() # Actor update self.actor.zero_grad() policy_loss = -self.critic( [to_tensor(state_batch), self.actor(to_tensor(state_batch))]) policy_loss = policy_loss.mean() policy_loss.backward() self.actor_optim.step() # Target update self.soft_update(self.actor_target, self.actor) self.soft_update(self.critic_target, self.critic)
def __getitem__(self, idx): image = utils.load_image(self.images[idx]) # image = self.images[idx] label = utils.to_tensor(self.labels[idx], torch.long) if self.transforms is not None: image = self.transforms(image) if self.output_name: return image, label, self.images[idx] return image, label
def main(): global words global word2idx print("ABSA ATAE-LSTM") #train_file = restaurant_train_file train_file = pd_data test_file = restaurant_test_file print("Overall Train Data :") vocab = file_stats(train_file, pd_data=True) # Return data without 'conflict' and print stats # Shuffle the data p = np.random.permutation(len(vocab)) vocab = np.array(vocab)[p] #test_vocab = file_stats(test_file, pd_data=False) # Create word vocab and weights for embedding words, word2idx = create_word_vocab(vocab, words, word2idx) #words, word2idx = create_word_vocab(test_vocab, words, word2idx) ################################################################################# ######################### Train/ Val Split ###################################### ################################################################################# print("Splitting training data in 80/20 for train/valid") train_len = int(0.8 * len(vocab)) valid_len = int(1 * len(vocab)) train_vocab = vocab[:train_len] valid_vocab = vocab[train_len:valid_len] #test_vocab = vocab[valid_len:] """ with open("train_pd_data.pickle", "wb") as f: pickle.dump(train_vocab, f) with open("valid_pd_data.pickle", "wb") as f: pickle.dump(valid_vocab, f) with open("test_pd_data.pickle", "wb") as f: pickle.dump(test_vocab, f)""" print("\nTraining set :") file_stats(train_vocab, return_vocab=False) print("\nValidation set :") file_stats(valid_vocab, return_vocab=False) # Weight matrix weights_matrix = create_weights(words, word2idx) #print(weights_matrix.shape) #train_vocab = vocab #valid_vocab = test_vocab train_vocab = to_tensor(train_vocab, word2idx) valid_vocab = to_tensor(valid_vocab, word2idx) train_set = vocabDataset(train_vocab) valid_set = vocabDataset(valid_vocab) labels = [] for data in train_set: labels.append(data['sentiment']) labels = torch.stack(labels) valid_batch = DataLoader(valid_set, batch_size=32, shuffle=True) #b_sampler = ATAE_BatchSampler(labels, batch_size=32) weights=np.array([1.5e-05,0.0002,1.8e-05]) label_weights = weights[labels.numpy()] sampler = torch.utils.data.WeightedRandomSampler(weights= label_weights, num_samples=len(label_weights),replacement=True) train_batch = DataLoader(train_set, batch_size=32, shuffle=False, sampler=sampler,batch_sampler=None) #train_batch = DataLoader(train_set, batch_sampler=b_sampler) hidden_dim = 300 output_dim = 3 # positive, negative, neutral dropout = 0.5 model = ATAE_LSTM(weights_matrix, hidden_dim, output_dim, dropout, words, word2idx) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.01, weight_decay=1e-3) #optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr = 0.1, momentum=0.9, weight_decay=1e-5) ########################################################################################## ##################### L2 only on weights ############################################## ########################################################################################## """ L2_params_id = [id(p) for p in model.Wp] + [id(p) for p in model.Wx] + [id(p) for p in model.fc.weight] + [id(p) for p in model.attn.weight] L2_params = [p for p in model.parameters() if id(p) in L2_params_id and p.requires_grad] base_params = [p for p in model.parameters() if id(p) not in L2_params_id and p.requires_grad] optimizer = optim.Adam([ {'params': base_params}, {'params': L2_params, 'weight_decay': 1e-3}, ], lr=0.01) """ weighted_loss = torch.tensor([1,1,1]).float() criterion = nn.CrossEntropyLoss(weight=weighted_loss.cuda()) for epoch in range(100): t_loss, t_acc, cm1 = model.train_(train_batch, optimizer, criterion) v_loss, v_acc, cm2 = model.eval_(valid_batch, criterion) log_value('loss/train_loss', t_loss, epoch) log_value('loss/valid_loss', v_loss, epoch) log_value('acc/train_acc', t_acc, epoch) log_value('acc/valid_acc', v_acc, epoch) print(cm1) print(cm2) print(f'Epoch: {epoch+1:02}, Train Loss: {t_loss:.8f}, Train Acc: {t_acc*100:.2f}%, \ Val. Loss: {v_loss:.8f}, Val. Acc: {v_acc*100:.2f}%') path = "Saved_Models/PD8/10epoch_" + str(epoch) torch.save(model, path) path = "Saved_Models/pd_10" torch.save(model, path) print("Training done") print("Model saved at ", path)