def train(model,trainLoader,criterion, optimizer,evalData = None, epoch=1,echoStep=100,evalStep=1000,saveStep=5000,savePath="./"): if evalData != None: evalX,evalY = evalData if torch.cuda.is_available(): evalY = evalY.cuda() if isinstance (evalX,list): for ti,t in enumerate(evalX): evalX[ti] = evalX[ti].cuda() else: evalX = evalX.cuda() batchLen = len(trainLoader) for epochIdx in xrange(epoch): for i,batch in enumerate(trainLoader,batchLen * epochIdx + 1): x, y = batch if torch.cuda.is_available(): y = y.cuda() if isinstance (x,list): for ti,t in enumerate(x): x[ti] = x[ti].cuda() else: x = x.cuda() out = model(x) loss = criterion(out, y) prob = F.softmax(out, 1) pred = torch.argmax(out, dim=1) correct = pred.eq(y).sum() acc = float(correct) / len(y) #print loss if i % echoStep == 0: print "Step %d/%d/%d : Loss %.4f , Acc %.4f " %(i,batchLen*epoch,epochIdx+1,float(loss),acc) #evaluate if i % evalStep == 0 and evalData != None: evalOut = model(evalX) evalLoss = criterion(evalOut, evalY) correct = torch.argmax(F.softmax(evalOut, 1) , dim=1).eq(evalY).sum() evalAcc = float(correct) / len(evalY) print "------------------------------------------------" print "Evaluate %d Sample : Loss %.4f , Acc %.4f " %(evalY.size(0),float(evalLoss),evalAcc) print #save model if i % saveStep == 0: outFile = "%s/m_%d_%d.pt" %(savePath,i,epochIdx+1) torch.save(model.state_dict(),outFile) print "Save model : %s" %(outFile) #backward optimizer.zero_grad() loss.backward() optimizer.step() outFile = "%s/final.pt" %(savePath) torch.save(model.state_dict(),outFile) print "Save model : %s" %(outFile)
def run(self): # Loss and Optimizer criterion = nn.CrossEntropyLoss() params = filter(lambda p: p.requires_grad, self.model.parameters()) optimizer = self.opt.optimizer(params, lr=self.opt.learning_rate) max_test_acc = 0 global_step = 0 for epoch in range(self.opt.num_epoch): print('>' * 100) print('epoch: ', epoch) n_correct, n_total = 0, 0 for i_batch, sample_batched in enumerate(self.train_data_loader): global_step += 1 # switch model to training mode, clear gradient accumulators self.model.train() optimizer.zero_grad() inputs = [sample_batched[col].to(opt.device) for col in self.opt.inputs_cols] targets = sample_batched['polarity'].to(opt.device) outputs = self.model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() if global_step % self.opt.log_step == 0: n_correct += (torch.argmax(outputs, -1) == targets).sum().item() n_total += len(outputs) train_acc = n_correct / n_total # switch model to evaluation mode self.model.eval() n_test_correct, n_test_total = 0, 0 with torch.no_grad(): for t_batch, t_sample_batched in enumerate(self.test_data_loader): t_inputs = [t_sample_batched[col].to(opt.device) for col in self.opt.inputs_cols] t_targets = t_sample_batched['polarity'].to(opt.device) t_outputs = self.model(t_inputs) n_test_correct += (torch.argmax(t_outputs, -1) == t_targets).sum().item() n_test_total += len(t_outputs) test_acc = n_test_correct / n_test_total if test_acc > max_test_acc: max_test_acc = test_acc print('loss: {:.4f}, acc: {:.4f}, test_acc: {:.4f}'.format(loss.item(), train_acc, test_acc)) # log self.writer.add_scalar('loss', loss, global_step) self.writer.add_scalar('acc', train_acc, global_step) self.writer.add_scalar('test_acc', test_acc, global_step) self.writer.close() print('max_test_acc: {0}'.format(max_test_acc)) return max_test_acc
def __init__(self, probs=None, logits=None, validate_args=None): if probs is not None: new_probs = torch.zeros_like(probs, dtype=torch.float) new_prob[torch.argmax(probs, dim=0)] = 1.0 probs = new_probs elif logits is not None: new_logits = torch.full_like(logits, -1e8, dtype=torch.float) max_idx = torch.argmax(logits, dim=0) new_logits[max_idx] = logits[max_idx] logits = new_logits super(Argmax, self).__init__(probs=probs, logits=logits, validate_args=validate_args)
def sample_relax(logits, surrogate): cat = Categorical(logits=logits) u = torch.rand(B,C).clamp(1e-10, 1.-1e-10).cuda() gumbels = -torch.log(-torch.log(u)) z = logits + gumbels b = torch.argmax(z, dim=1) #.view(B,1) logprob = cat.log_prob(b).view(B,1) # czs = [] # for j in range(1): # z = sample_relax_z(logits) # surr_input = torch.cat([z, x, logits.detach()], dim=1) # cz = surrogate.net(surr_input) # czs.append(cz) # czs = torch.stack(czs) # cz = torch.mean(czs, dim=0)#.view(1,1) surr_input = torch.cat([z, x, logits.detach()], dim=1) cz = surrogate.net(surr_input) cz_tildes = [] for j in range(1): z_tilde = sample_relax_given_b(logits, b) surr_input = torch.cat([z_tilde, x, logits.detach()], dim=1) cz_tilde = surrogate.net(surr_input) cz_tildes.append(cz_tilde) cz_tildes = torch.stack(cz_tildes) cz_tilde = torch.mean(cz_tildes, dim=0) #.view(B,1) return b, logprob, cz, cz_tilde
def viterbi(self, emit, mask): T, B, N = emit.shape lens = mask.sum(dim=0) delta = torch.zeros(T, B, N) paths = torch.zeros(T, B, N, dtype=torch.long) delta[0] = self.strans + emit[0] # [B, N] for i in range(1, T): trans_i = self.trans.unsqueeze(0) # [1, N, N] emit_i = emit[i].unsqueeze(1) # [B, 1, N] scores = trans_i + emit_i + delta[i - 1].unsqueeze(2) # [B, N, N] delta[i], paths[i] = torch.max(scores, dim=1) predicts = [] for i, length in enumerate(lens): prev = torch.argmax(delta[length - 1, i] + self.etrans) predict = [prev] for j in reversed(range(1, length)): prev = paths[j, i, prev] predict.append(prev) # 反转预测序列并保存 predicts.append(torch.tensor(predict).flip(0)) return torch.cat(predicts)
def test(model): game_state = GameState() # initial action is do nothing action = torch.zeros([model.number_of_actions], dtype=torch.float32) action[0] = 1 image_data, reward, terminal = game_state.frame_step(action) image_data = resize_and_bgr2gray(image_data) image_data = image_to_tensor(image_data) state = torch.cat((image_data, image_data, image_data, image_data)).unsqueeze(0) while True: # get output from the neural network output = model(state)[0] action = torch.zeros([model.number_of_actions], dtype=torch.float32) if torch.cuda.is_available(): # put on GPU if CUDA is available action = action.cuda() # get action action_index = torch.argmax(output) if torch.cuda.is_available(): # put on GPU if CUDA is available action_index = action_index.cuda() action[action_index] = 1 # get next state image_data_1, reward, terminal = game_state.frame_step(action) image_data_1 = resize_and_bgr2gray(image_data_1) image_data_1 = image_to_tensor(image_data_1) state_1 = torch.cat((state.squeeze(0)[1:, :, :], image_data_1)).unsqueeze(0) # set state to be state_1 state = state_1
def get_pm_loss(self, image, alpha = 0.0, topk = 0, use_baseline = True, use_term_one_baseline = True, n_samples = 1): class_weights = self.pixel_attention(image) log_q = torch.log(class_weights) # kl term kl_pixel_probs = (class_weights * log_q).sum() f_pixel = lambda i : self.get_loss_cond_pixel_1d(image, i) + \ kl_pixel_probs avg_pm_loss = 0.0 # TODO: n_samples would be more elegant as an # argument to get_partial_marginal_loss for k in range(n_samples): pm_loss = pm_lib.get_partial_marginal_loss(f_pixel, log_q, alpha, topk, use_baseline = use_baseline, use_term_one_baseline = use_term_one_baseline) avg_pm_loss += pm_loss / n_samples map_locations = torch.argmax(log_q.detach(), dim = 1) map_cond_losses = f_pixel(map_locations).mean() return avg_pm_loss, map_cond_losses
def sample_relax(probs): #Sample z u = torch.rand(B,C) gumbels = -torch.log(-torch.log(u)) z = torch.log(probs) + gumbels b = torch.argmax(z, dim=1) logprob = cat.log_prob(b) #Sample z_tilde u_b = torch.rand(B,1) z_tilde_b = -torch.log(-torch.log(u_b)) u = torch.rand(B,C) z_tilde = -torch.log((- torch.log(u) / probs) - torch.log(u_b)) # print (z_tilde) z_tilde[:,b] = z_tilde_b # print (z_tilde) # fasdfasd # print (z) # print (b) # print (z_tilde) # print (logprob) # print (probs) # fsdfa return z, b, logprob, z_tilde
def forward_greedy(self,z,num_steps,temperature,x=None): batch_size = z.size(0) predictions = [] z = self.batchnorm1(self.activation(self.z2m(z))) # detach memory such that we don't backprop through the whole dataset memory = self.initMemory(batch_size).to(z.device) memory = memory.detach() previous_output = z.new_zeros(size=(z.size(0),),dtype=torch.long) previous_output[:] = self.SOS_TOKEN # <sos> token for i in range(num_steps): input = self.activation(self.embedding(previous_output)) if x is not None: input = self.input_dropout(input) step_input = torch.cat([input,z],dim=1) step_input = self.batchnorm2(step_input) memory = self.relRNN(step_input,memory) out = self.m2o(memory.view(memory.size(0),-1)) out = self.last_activation(out,temperature) if x is not None: # teacher forcing previous_output = x[:,i] else: # use prediction as input previous_output = torch.argmax(out,dim=-1) previous_output = previous_output.detach() predictions.append(out) output = torch.stack(predictions).transpose(1,0) return output
def forward_greedy(self,z,num_steps,temperature,x=None): if num_steps > self.max_seq_len: raise ValueError("num_steps ({}) must be less or equal to max_seq_len ({})".format(num_steps,self.max_seq_len)) predictions = [] z = self.batchnorm1(self.activation(self.z2h(z))) hx = z # initialize the hidden state hm = z # initialize the hidden state for memory memory = self.memory memory = memory[:num_steps,:] memory = memory.expand(z.size(0),-1,-1) # copy the memory for each batch position previous_output = z.new_zeros(size=(z.size(0),),dtype=torch.long) previous_output[:] = self.SOS_TOKEN # <sos> token # run rnn for i in range(num_steps): # for the input input = self.activation(self.embedding(previous_output)) # previous_output is of size [batch,hidden_size] step_input = torch.cat([input,z],dim=1) # step_input is of size [batch,step_input_size] step_input = self.batchnorm2(step_input) step_mem = memory[:,i,:] # step_mem is of size [batch,step_input_size] out,hx,hm = self.memcell(step_input,step_mem,hx=hx,hm=hm) out = self.activation(out) out = self.batchnorm3(out) out = self.h2o(out) out = self.last_activation(out,temperature) if x is not None: # teacher forcing previous_output = x[:,i] else: # use prediction as input previous_output = torch.argmax(out,dim=-1) previous_output = previous_output.detach() predictions.append(out) output = torch.stack(predictions).transpose(1,0) return output
def sample_relax(logits): #, k=1): # u = torch.rand(B,C).clamp(1e-8, 1.-1e-8) #.cuda() u = torch.rand(B,C).clamp(1e-12, 1.-1e-12) #.cuda() gumbels = -torch.log(-torch.log(u)) z = logits + gumbels b = torch.argmax(z, dim=1) cat = Categorical(logits=logits) logprob = cat.log_prob(b).view(B,1) v_k = torch.rand(B,1).clamp(1e-12, 1.-1e-12) z_tilde_b = -torch.log(-torch.log(v_k)) #this way seems biased even tho it shoudlnt be # v_k = torch.gather(input=u, dim=1, index=b.view(B,1)) # z_tilde_b = torch.gather(input=z, dim=1, index=b.view(B,1)) v = torch.rand(B,C).clamp(1e-12, 1.-1e-12) #.cuda() probs = torch.softmax(logits,dim=1).repeat(B,1) # print (probs.shape, torch.log(v_k).shape, torch.log(v).shape) # fasdfa # print (v.shape) # print (v.shape) z_tilde = -torch.log((- torch.log(v) / probs) - torch.log(v_k)) # print (z_tilde) # print (z_tilde_b) z_tilde.scatter_(dim=1, index=b.view(B,1), src=z_tilde_b) # print (z_tilde) # fasdfs return z, b, logprob, z_tilde
def forward_greedy(self,z,num_steps,temperature,x=None): predictions = [] batch_size = z.size(0) next_input = z.new_zeros(size=(batch_size,num_steps),dtype=torch.long,requires_grad=False) next_input[:,:] = self.PAD_TOKEN next_input[:,0] = self.SOS_TOKEN # <sos> token z = self.activation(self.z2h(z)).view(batch_size,1,-1).repeat(1,num_steps,1) for i in range(num_steps): input = next_input step_input = self.embedding(input) step_input = self.pos_embedding(step_input) step_input = torch.cat([step_input,z],dim=2) # step_input is of size [batch,seq_len,step_input_size] step_input = self.activation(self.s2h(step_input)) non_pad_mask = get_non_pad_mask(input,self.PAD_TOKEN) slf_attn_mask_subseq = get_subsequent_mask(input) slf_attn_mask_keypad = get_attn_key_pad_mask(input,self.PAD_TOKEN) attn_mask = (slf_attn_mask_keypad + slf_attn_mask_subseq).gt(0) out = self.transformer(step_input,non_pad_mask=non_pad_mask,attn_mask=attn_mask) out = out[:,i,:] out = self.activation(out) out = self.h2o(out) out = self.last_activation(out,temperature) if x is not None: # teacher forcing previous_output = x[:,i] else: # use prediction as input previous_output = torch.argmax(out,dim=-1) previous_output = previous_output.detach() next_input = torch.cat([input[:,:i+1],previous_output.view(-1,1),input[:,i+2:]],dim=1).detach() predictions.append(out) output = torch.stack(predictions).transpose(1,0) return output
def get_pm_loss(self, image, image_so_far, var_so_far, alpha = 0.0, topk = 0, use_baseline = True, use_term_one_baseline = True, n_samples = 1): resid_image = image - image_so_far class_weights = self.get_pixel_probs(resid_image, var_so_far) log_q = torch.log(class_weights) # kl term kl_a = (class_weights * log_q).sum() f_z = lambda i : self.get_loss_conditional_a(resid_image, image_so_far, var_so_far, i)[0] + kl_a avg_pm_loss = 0.0 # TODO: n_samples would be more elegant as an # argument to get_partial_marginal_loss for k in range(n_samples): pm_loss = pm_lib.get_partial_marginal_loss(f_z, log_q, alpha, topk, use_baseline = use_baseline, use_term_one_baseline = use_term_one_baseline) avg_pm_loss += pm_loss / n_samples map_locations = torch.argmax(log_q.detach(), dim = 1) map_cond_losses = f_z(map_locations).mean() return avg_pm_loss, map_cond_losses
def train(model, trn_loader, optimizer, loss_func, device): model.train() training_loss = 0 training_acc = 0 counter = 0 for data, target in trn_loader: data = Variable(data.to(device)) target = Variable(target.to(device)) # Forward pass output = model(data) tloss = loss_func(output, target) training_loss += tloss.item() # Zero the gradients optimizer.zero_grad() # Backward pass tloss.backward() # Update parameters optimizer.step() # Compute prediction's score pred = torch.argmax(output.data, 1) training_acc += accuracy_score(target.data.cpu().numpy(), pred.data.cpu().numpy()) counter += 1 avg_loss = training_loss / float(counter) avg_acc = training_acc / float(counter) return avg_loss, avg_acc
def predict(model, data, device): model.eval() with torch.no_grad(): data = data.to(device) output = model(data) pred = torch.argmax(output.data, 1) return output, pred
def _get_state_action_values(self, transitions): batch_size = len(transitions) batch = Transition(*zip(*transitions)) non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch.next_state)), dtype=torch.uint8, device=self.config.device) state_batch = torch.cat(batch.state).to(torch.float32) action_batch = torch.cat(batch.action) reward_batch = torch.cat(batch.reward).to(torch.float32) next_state_values = torch.zeros(batch_size).to(self.config.device, dtype=torch.float32) next_states = [s for s in batch.next_state if s is not None] if len(next_states) != 0: with torch.no_grad(): non_final_next_state = torch.cat(next_states).to(torch.float32) Q = self._get_Q(self.model, non_final_next_state) best_actions = torch.argmax(Q, dim=1, keepdim=True) Q_target = self._get_Q(self.target_model, non_final_next_state) next_state_values[non_final_mask] = Q_target.gather(1, best_actions).squeeze() gamma = self.config.gamma ** self.config.num_multi_step_reward expected_values = reward_batch + gamma * next_state_values with torch.set_grad_enabled(self.model.training): Q = self._get_Q(self.model, state_batch) values = torch.squeeze(Q.gather(1, action_batch)) values.to(self.config.device, dtype=torch.float32) return (values, expected_values)
def predict(model, batches, weights_matrix): model.embedding, _ = create_emb_layer(weights_matrix) model.embedding = model.embedding.cuda() model.eval() # Only 1 batch and 1 item in that batch for batch in batches: pred = model(batch) return torch.argmax(F.softmax(pred,dim=1),1)
def predict_image(image_path): img = Image.open(image_path) img = transformations(img) pred = model.predict(img,apply_softmax=True) # print the class and accuracy predicted print("Prediction: {} , Accuracy: {} ".format(torch.argmax(pred), torch.max(pred)))
def predict_loader(data_loader): #compute predictions and apply softmax predictions = model.predict(data_loader,apply_softmax=True) #print the class and accuracy for each prediction for pred in predictions: print("Prediction: {} , Accuracy: {} ".format(torch.argmax(pred), torch.max(pred)))
def predict(self, X): """ sklearn interface without creating graph """ X = X.to(device =self.cf_a.device ) if (self.cf_a.task_type == "regression"): with torch.no_grad(): return self.forward(X) elif(self.cf_a.task_type == "classification"): with torch.no_grad(): return torch.argmax(self.forward(X),1)
def test(model, batches, weights_matrix): model.embedding, _ = create_emb_layer(weights_matrix) model.embedding = model.embedding.cuda() model.eval() total_acc = 0 count = 0 cm = torch.zeros(3,3) for batch in batches: batch = create_sorted_batch(batch) label = batch['sentiment'] pred = model(batch) acc = accuracy(torch.argmax(F.softmax(pred,dim=1),1).float(), label.float().cuda()) cm += torch.from_numpy(confusion_matrix(label, torch.argmax(pred,1), \ labels=[torch.tensor(0), torch.tensor(1), torch.tensor(2)])).float() total_acc += acc.item() count += len(label) return total_acc/count, cm
def eval_(model, batches, criterion): model.eval() total_loss = 0 total_acc = 0 count = 0 cm = torch.zeros(3,3) for batch in batches: batch = create_sorted_batch(batch) label = batch['sentiment'] pred = model(batch) loss = criterion(pred, label.cuda()) acc = accuracy(torch.argmax(F.softmax(pred,dim=1),1).float(), label.float().cuda()) cm += torch.from_numpy(confusion_matrix(label, torch.argmax(pred,1), \ labels=[torch.tensor(0), torch.tensor(1), torch.tensor(2)])).float() total_loss += loss.item() total_acc += acc.item() count += len(label) return total_loss/len(batches), total_acc/count, cm
def perform_inference_helper(self, test_features): """ Helper function for ClassifierModel's perform_inference(self, test_features, test_labels) """ # Use inference model self.model.eval() predictions = (self.model((torch.from_numpy(test_features).float()).to(self.device))).cpu().detach() predictions = (torch.argmax(predictions, 1)).numpy() return predictions
def run(input_data): input_data = torch.tensor(json.loads(input_data)['data']) # get prediction with torch.no_grad(): output = model(input_data) classes = ['ants', 'bees'] softmax = nn.Softmax(dim=1) pred_probs = softmax(output).numpy()[0] index = torch.argmax(output, 1) result = {"label": classes[index], "probability": str(pred_probs[index])} return result
def sample_with_temperature(logits, sampling_temp, keep_topk): """Select next tokens randomly from the top k possible next tokens. Samples from a categorical distribution over the ``keep_topk`` words using the category probabilities ``logits / sampling_temp``. Args: logits (FloatTensor): Shaped ``(batch_size, vocab_size)``. These can be logits (``(-inf, inf)``) or log-probs (``(-inf, 0]``). (The distribution actually uses the log-probabilities ``logits - logits.logsumexp(-1)``, which equals the logits if they are log-probabilities summing to 1.) sampling_temp (float): Used to scale down logits. The higher the value, the more likely it is that a non-max word will be sampled. keep_topk (int): This many words could potentially be chosen. The other logits are set to have probability 0. Returns: (LongTensor, FloatTensor): * topk_ids: Shaped ``(batch_size, 1)``. These are the sampled word indices in the output vocab. * topk_scores: Shaped ``(batch_size, 1)``. These are essentially ``(logits / sampling_temp)[topk_ids]``. """ if sampling_temp == 0.0 or keep_topk == 1: # For temp=0.0, take the argmax to avoid divide-by-zero errors. # keep_topk=1 is also equivalent to argmax. topk_scores, topk_ids = logits.topk(1, dim=-1) if sampling_temp > 0: topk_scores /= sampling_temp else: logits = torch.div(logits, sampling_temp) if keep_topk > 0: top_values, top_indices = torch.topk(logits, keep_topk, dim=1) kth_best = top_values[:, -1].view([-1, 1]) kth_best = kth_best.repeat([1, logits.shape[1]]).float() # Set all logits that are not in the top-k to -10000. # This puts the probabilities close to 0. ignore = torch.lt(logits, kth_best) logits = logits.masked_fill(ignore, -10000) dist = torch.distributions.Multinomial( logits=logits, total_count=1) topk_ids = torch.argmax(dist.sample(), dim=1, keepdim=True) topk_scores = logits.gather(dim=1, index=topk_ids) return topk_ids, topk_scores
def get_unlabeled_pm_loss(self, image, topk = 0, use_baseline = True, true_labels = None): # true labels for debugging only: if true_labels is None: log_q = self.classifier(image) #; print('max: ', torch.max(log_q)); print('min: ', torch.min(log_q)); assert np.all(log_q.detach().cpu().numpy() <= 0) else: # print('using true labels') batch_size = image.shape[0] q = torch.zeros((batch_size, self.n_classes)) + 1e-12 seq_tensor = torch.LongTensor([i for i in range(batch_size)]) q[seq_tensor, true_labels] = 1 - 1e-12 * (self.n_classes - 1) log_q = torch.log(q).to(device) f_z = lambda z : self.get_conditional_loss(image, z) if true_labels is None: pm_loss_z = pm_lib.get_partial_marginal_loss(f_z, log_q, alpha = 0.0, topk = topk, use_baseline = use_baseline, use_term_one_baseline = True) else: # we set log_q here to be the true labels pm_loss_z = self.get_conditional_loss(image, \ torch.argmax(log_q, dim = 1).detach()) # kl term for class weights # (assuming uniform prior) kl_q_z = (torch.exp(log_q) * log_q).sum() # sampled loss: map_weights = torch.argmax(log_q, dim = 1) map_loss = f_z(map_weights) return pm_loss_z + kl_q_z, map_loss.sum()
def main(): # Load model if torch.cuda.is_available(): model = torch.load("trained_models/whole_model_quickdraw") else: model = torch.load("trained_models/whole_model_quickdraw", map_location=lambda storage, loc: storage) model.eval() image = np.zeros((480, 640, 3), dtype=np.uint8) cv2.namedWindow("Canvas") global ix, iy, is_drawing is_drawing = False def paint_draw(event, x, y, flags, param): global ix, iy, is_drawing if event == cv2.EVENT_LBUTTONDOWN: is_drawing = True ix, iy = x, y elif event == cv2.EVENT_MOUSEMOVE: if is_drawing == True: cv2.line(image, (ix, iy), (x, y), WHITE_RGB, 5) ix = x iy = y elif event == cv2.EVENT_LBUTTONUP: is_drawing = False cv2.line(image, (ix, iy), (x, y), WHITE_RGB, 5) ix = x iy = y return x, y cv2.setMouseCallback('Canvas', paint_draw) while (1): cv2.imshow('Canvas', 255 - image) key = cv2.waitKey(10) if key == ord(" "): image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) ys, xs = np.nonzero(image) min_y = np.min(ys) max_y = np.max(ys) min_x = np.min(xs) max_x = np.max(xs) image = image[min_y:max_y, min_x: max_x] image = cv2.resize(image, (28, 28)) image = np.array(image, dtype=np.float32)[None, None, :, :] image = torch.from_numpy(image) logits = model(image) print(CLASSES[torch.argmax(logits[0])]) image = np.zeros((480, 640, 3), dtype=np.uint8) ix = -1 iy = -1
def accuracy2(pred, label): # Accuracy, Precision, Recall, F1 """ Create confusion matrix and do the calculations C[i][j] = number of observations known to be in group i but predicted to be in group j Precision = True Positive / (True Positive + False Positive) = True positive / Total predicted Recall = True Positive / (True Positive + False Negative) = True positive / Total actual F1 score = 2* (Precision * Recall) / (Precision + Recall) """ cm = confusion_matrix(torch.argmax(pred,1), label, labels=tto[0, 1, 2]) print(cm) print(cm.shape)
def sample_relax(logits): cat = Categorical(logits=logits) u = torch.rand(B,C).clamp(1e-8, 1.-1e-8)#.cuda() gumbels = -torch.log(-torch.log(u)) z = logits + gumbels b = torch.argmax(z, dim=1) logprob = cat.log_prob(b).view(B,1) u_b = torch.gather(input=u, dim=1, index=b.view(B,1)) z_tilde_b = -torch.log(-torch.log(u_b)) z_tilde = -torch.log((- torch.log(u) / torch.softmax(logits, dim=1)) - torch.log(u_b)) z_tilde.scatter_(dim=1, index=b.view(B,1), src=z_tilde_b) return z, b, logprob, z_tilde
def test(model, vali_loader, loss_func, device): model.eval() test_loss = 0 counter = 0 preds = list() for data, target in vali_loader: with torch.no_grad(): data = data.to(device) target = target.to(device) output = model(data) test_loss += loss_func(output, target).item() pred = torch.argmax(output.data, 1) preds += pred.cpu().numpy().tolist() counter += 1 avg_loss = test_loss / float(counter) return preds, avg_loss
def _process_feature_extraction(self, output, im_scales, im_infos, feature_name="fc6", conf_thresh=0): batch_size = len(output[0]["proposals"]) n_boxes_per_image = [len(boxes) for boxes in output[0]["proposals"]] score_list = output[0]["scores"].split(n_boxes_per_image) score_list = [torch.nn.functional.softmax(x, -1) for x in score_list] feats = output[0][feature_name].split(n_boxes_per_image) cur_device = score_list[0].device feat_list = [] info_list = [] for i in range(batch_size): dets = output[0]["proposals"][i].bbox / im_scales[i] scores = score_list[i] max_conf = torch.zeros(scores.shape[0]).to(cur_device) conf_thresh_tensor = torch.full_like(max_conf, conf_thresh) start_index = 1 # Column 0 of the scores matrix is for the background class if self.args.background: start_index = 0 for cls_ind in range(start_index, scores.shape[1]): cls_scores = scores[:, cls_ind] keep = nms(dets, cls_scores, 0.5) max_conf[keep] = torch.where( # Better than max one till now and minimally greater # than conf_thresh (cls_scores[keep] > max_conf[keep]) & (cls_scores[keep] > conf_thresh_tensor[keep]), cls_scores[keep], max_conf[keep], ) sorted_scores, sorted_indices = torch.sort(max_conf, descending=True) num_boxes = (sorted_scores[:self.args.num_features] != 0).sum() keep_boxes = sorted_indices[:self.args.num_features] feat_list.append(feats[i][keep_boxes]) bbox = output[0]["proposals"][i][keep_boxes].bbox / im_scales[i] # Predict the class label using the scores objects = torch.argmax(scores[keep_boxes][:, start_index:], dim=1) info_list.append({ "bbox": bbox.cpu().numpy(), "num_boxes": num_boxes.item(), "objects": objects.cpu().numpy(), "cls_prob": scores[keep_boxes][:, start_index:].cpu().numpy(), "image_width": im_infos[i]["width"], "image_height": im_infos[i]["height"], }) return feat_list, info_list
# data load X = X.to(device) Y = Y.to(device) # CNN 모델을 통해 비용 측정 hypothesis = model(X) cost = criterion(hypothesis, Y) # 변화도 누적 초기화 optimizer.zero_grad() # 역전파 cost.backward() # 모델 갱신 과정 optimizer.step() avg_cost += cost / total_batch print('[Epoch: {:>4}] cost = {:>.9}'.format(epoch + 1, avg_cost)) # 학습하지 않을 때의 코드, 가중치 갱신 과정은 생략함 with torch.no_grad(): X_test = mnist_test.test_data.view(len(mnist_test), 1, 28, 28).float().to(device) Y_test = mnist_test.test_labels.to(device) prediction = model(X_test) correct_prediction = torch.argmax(prediction, 1) == Y_test accuracy = correct_prediction.float().mean() print('Accuracy:', accuracy.item())
scale_tracked = [] scale_lower = 0.00001 scale_higher = 0.1 for global_step in range(args.total_timesteps): # ALGO LOGIC: put action logic here epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction*args.total_timesteps, global_step) obs = np.array(obs) # action, logits, _, = sampler.sample(q_network, obs, device, n, epsilon) logits, n, mu, scale = q_network.forward(obs.reshape((1,)+obs.shape), device) if on_levy == 0: on_levy = n.clone().detach().cpu().numpy() on_levy = np.clip(np.floor(on_levy) + 1, 0, args.clip_n) n_tracked.append(int(on_levy)) current_levy_action = torch.argmax(logits, dim=1).tolist()[0] scale_tracked.append(int(scale))# if random.random() < epsilon: action = env.action_space.sample() elif on_levy > 0: action = current_levy_action else: action = torch.argmax(logits, dim=1).tolist()[0] on_levy = on_levy - 1 # EXPERIMhENTAL PLEASE FIX SOON # TRY NOT TO MODIFY: execute the game and log data. next_obs, reward, done, info = env.step(action) episode_reward += reward # TRY NOT TO MODIFY: record rewards for plotting purposes
]) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') feature_extractor = CNN_VAE().to(device) #feature_extractor = FeatureExtractor().cuda() label_predictor = LabelPredictor().to(device) feature_extractor.load_state_dict(torch.load('extractor_model.bin')) label_predictor.load_state_dict(torch.load('predictor_model.bin')) target_dataset = ImageFolder(os.path.join(sys.argv[1], 'test_data'), transform=target_transform) test_dataloader = DataLoader(target_dataset, batch_size=128, shuffle=False) result = [] label_predictor.eval() feature_extractor.eval() for i, (test_data, _) in enumerate(test_dataloader): test_data = test_data.to(device) class_logits = label_predictor(feature_extractor(test_data)) x = torch.argmax(class_logits, dim=1).cpu().detach().numpy() result.append(x) import pandas as pd result = np.concatenate(result) # Generate your submission df = pd.DataFrame({'id': np.arange(0, len(result)), 'label': result}) df.to_csv(sys.argv[2], index=False)
def train(snapshotroot, device, forestType, numTrees, depth): xtrain, ytrain, xtest, ytest = datasets.load_usps() xtrain = np.reshape(xtrain, [-1, 256]) xtest = np.reshape(xtest, [-1, 256]) # XXX: Other papers use val = test for this data set xval = xtest yval = ytest # Transfer this data to the device xtrain = torch.from_numpy(xtrain).type(torch.float32).to(device) ytrain = torch.from_numpy(ytrain).type(torch.long).to(device) xval = torch.from_numpy(xval).type(torch.float32).to(device) yval = torch.from_numpy(yval).type(torch.long).to(device) xtest = torch.from_numpy(xtest).type(torch.float32).to(device) ytest = torch.from_numpy(ytest).type(torch.long).to(device) net = Net(forestType, numTrees, depth).to(device) criterion = nn.CrossEntropyLoss().to(device) optimizer = optim.Adam(net.parameters(), lr=0.001) # Count parameters numParams = sum(params.numel() for params in net.parameters()) numTrainable = sum(params.numel() for params in net.parameters() if params.requires_grad) print( f"There are {numParams} parameters total in this model ({numTrainable} are trainable)" ) numEpochs = 200 batchSize = 23 indices = [i for i in range(xtrain.shape[0])] bestEpoch = numEpochs - 1 bestAccuracy = 0.0 bestLoss = 1000.0 valLosses = np.zeros([numEpochs]) for epoch in range(numEpochs): random.shuffle(indices) xtrain = xtrain[indices, :] ytrain = ytrain[indices] runningLoss = 0.0 count = 0 for xbatch, ybatch in batches(xtrain, ytrain, batchSize): #t = time.time() optimizer.zero_grad() outputs = net(xbatch) loss = criterion(outputs, ybatch) loss.backward() optimizer.step() runningLoss += loss count += 1 #print(f"elapsed = {time.time() - t}, count = {count}") meanLoss = runningLoss / count snapshotFile = os.path.join(snapshotroot, f"epoch_{epoch}") torch.save(net.state_dict(), snapshotFile) runningLoss = 0.0 count = 0 with torch.no_grad(): net.train(False) #for xbatch, ybatch in batches(xval, yval, batchSize): for xbatch, ybatch in zip([xval], [yval]): outputs = net(xbatch) loss = criterion(outputs, ybatch) runningLoss += loss count += 1 net.train(True) valLoss = runningLoss / count if valLoss < bestLoss: bestLoss = valLoss bestEpoch = epoch #print(f"Info: Epoch = {epoch}, loss = {meanLoss}, validation loss = {valLoss}") valLosses[epoch] = valLoss snapshotFile = os.path.join(snapshotroot, f"epoch_{bestEpoch}") net = Net(forestType, numTrees, depth) net.load_state_dict(torch.load(snapshotFile, map_location="cpu")) net = net.to(device) totalCorrect = 0 count = 0 with torch.no_grad(): net.train(False) #for xbatch, ybatch in batches(xtest, ytest, batchSize): for xbatch, ybatch in zip([xtest], [ytest]): outputs = net(xbatch) outputs = torch.argmax(outputs, dim=1) tmpCorrect = torch.sum(outputs == ybatch) totalCorrect += tmpCorrect count += xbatch.shape[0] accuracy = float(totalCorrect) / float(count) print( f"Info: Best epoch = {bestEpoch}, test accuracy = {accuracy}, misclassification rate = {1.0 - accuracy}" ) return accuracy, valLosses
def inference(args): # Check for CUDA device = torch.device("cuda" if torch.cuda.is_available() else "cpu") logging.warning(f"--- Using device {device}! ---") # Create datasets visual2index = json.load( open(os.path.join(args.visuals_dicts_path, "visual2index.json")) ) word2freq, word2index, _ = build_vocab(json.load(open(args.train_dataset_path))) test_dataset = InferenceDataset( args.test_dataset_path, word2freq, word2index, visual2index ) logging.info(f"Performing inference on {len(test_dataset)}") # Create loaders test_loader = DataLoader( test_dataset, batch_size=args.batch_size, num_workers=4, collate_fn=collate_pad_batch, ) num_cliparts = len(visual2index) + 1 vocab_size = len(word2index) model = nn.DataParallel( baseline_factory(args.baseline_name, num_cliparts, vocab_size, 256, device) ).to(device) model.load_state_dict(torch.load(args.checkpoint_path, map_location=device)) model.train(False) print(f"Starting inference from checkpoint {args.checkpoint_path}!") evaluator = Evaluator(len(test_dataset)) for batch in tqdm(test_loader): # forward batch = {key: val.to(device) for key, val in batch.items()} x_scores, y_scores, o_scores = model(batch["ids_text"], batch["ids_vis"]) if "discrete" in args.baseline_name: x_out, y_out = ( torch.argmax(x_scores, dim=-1) * BUCKET_SIZE + BUCKET_SIZE / 2, torch.argmax(y_scores, dim=-1) * BUCKET_SIZE + BUCKET_SIZE / 2, ) elif "continuous" in args.baseline_name: x_out, y_out = ( x_scores * BUCKET_SIZE + BUCKET_SIZE / 2, y_scores * BUCKET_SIZE + BUCKET_SIZE / 2, ) else: raise ValueError("Invalid model type!") o_out = torch.argmax(o_scores, dim=-1) evaluator.update_metrics( x_out, batch["x_lab"], y_out, batch["y_lab"], o_out, batch["o_lab"], batch["attn_mask"], ) print( f"The avg ABSOLUTE sim per scene is: {evaluator.get_abs_sim()} +/- {evaluator.get_abs_error_bar()}" ) print( f"The avg RELATIVE sim per scene is: {evaluator.get_rel_sim()} +/- {evaluator.get_rel_error_bar()}" ) print(f"The avg ACCURACY for the orientation is: {evaluator.get_o_acc()}") if args.abs_dump_path is not None and args.rel_dump_path is not None: evaluator.dump_results(args.abs_dump_path, args.rel_dump_path)
def compute_acc(pred, labels): """ Compute the accuracy of prediction given the labels. """ return (th.argmax(pred, dim=1) == labels).float().sum() / len(pred)
def train_volleyball(data_loader, model, device, optimizer, epoch, cfg): actions_meter = AverageMeter() activities_meter = AverageMeter() loss_meter = AverageMeter() epoch_timer = Timer() for batch_data in data_loader: model.train() model.apply(set_bn_eval) # prepare batch data batch_data = [b.to(device=device) for b in batch_data] batch_size = batch_data[0].shape[0] num_frames = batch_data[0].shape[1] actions_in = batch_data[2].reshape( (batch_size, num_frames, cfg.num_boxes)) activities_in = batch_data[3].reshape((batch_size, num_frames)) actions_in = actions_in[:, 0, :].reshape( (batch_size * cfg.num_boxes, )) activities_in = activities_in[:, 0].reshape((batch_size, )) # forward actions_scores, activities_scores = model( (batch_data[0], batch_data[1])) # Predict actions actions_weights = torch.tensor(cfg.actions_weights).to(device=device) actions_loss = F.cross_entropy(actions_scores, actions_in, weight=actions_weights) actions_labels = torch.argmax(actions_scores, dim=1) actions_correct = torch.sum( torch.eq(actions_labels.int(), actions_in.int()).float()) # Predict activities activities_loss = F.cross_entropy(activities_scores, activities_in) activities_labels = torch.argmax(activities_scores, dim=1) activities_correct = torch.sum( torch.eq(activities_labels.int(), activities_in.int()).float()) # Get accuracy actions_accuracy = actions_correct.item() / actions_scores.shape[0] activities_accuracy = activities_correct.item( ) / activities_scores.shape[0] actions_meter.update(actions_accuracy, actions_scores.shape[0]) activities_meter.update(activities_accuracy, activities_scores.shape[0]) # Total loss total_loss = activities_loss + cfg.actions_loss_weight * actions_loss loss_meter.update(total_loss.item(), batch_size) # Optim optimizer.zero_grad() total_loss.backward() optimizer.step() train_info = { 'time': epoch_timer.timeit(), 'epoch': epoch, 'loss': loss_meter.avg, 'activities_acc': activities_meter.avg * 100, 'actions_acc': actions_meter.avg * 100 } return train_info
def forward(self, p, img_size, targets=None, var=None): if ONNX_EXPORT: bs, nG = 1, self.nG # batch size, grid size else: bs, nG = p.shape[0], p.shape[-1] if self.img_size != img_size: self.create_grids(img_size, nG) if p.is_cuda: self.grid_xy = self.grid_xy.cuda() self.anchor_vec = self.anchor_vec.cuda() self.anchor_wh = self.anchor_wh.cuda() # p.view(bs, 255, 13, 13) -- > (bs, 3, 13, 13, 80) # (bs, anchors, grid, grid, classes + xywh) p = p.view(bs, self.nA, self.nC + 5, nG, nG).permute(0, 1, 3, 4, 2).contiguous() # prediction # xy, width and height xy = torch.sigmoid(p[..., 0:2]) wh = p[..., 2:4] # wh (yolo method) # wh = torch.sigmoid(p[..., 2:4]) # wh (power method) # Training if targets is not None: MSELoss = nn.MSELoss() BCEWithLogitsLoss = nn.BCEWithLogitsLoss() CrossEntropyLoss = nn.CrossEntropyLoss() # Get outputs p_conf = p[..., 4] # Conf p_cls = p[..., 5:] # Class txy, twh, mask, tcls = build_targets(targets, self.anchor_vec, self.nA, self.nC, nG) tcls = tcls[mask] if p.is_cuda: txy, twh, mask, tcls = txy.cuda(), twh.cuda(), mask.cuda( ), tcls.cuda() # Compute losses nT = sum([len(x) for x in targets]) # number of targets nM = mask.sum().float() # number of anchors (assigned to targets) k = 1 # nM / bs if nM > 0: lxy = k * MSELoss(xy[mask], txy[mask]) lwh = k * MSELoss(wh[mask], twh[mask]) lcls = (k / 4) * CrossEntropyLoss(p_cls[mask], torch.argmax(tcls, 1)) # lcls = (k * 10) * BCEWithLogitsLoss(p_cls[mask], tcls.float()) else: FT = torch.cuda.FloatTensor if p.is_cuda else torch.FloatTensor lxy, lwh, lcls, lconf = FT([0]), FT([0]), FT([0]), FT([0]) lconf = (k * 64) * BCEWithLogitsLoss(p_conf, mask.float()) # Sum loss components loss = lxy + lwh + lconf + lcls return loss, loss.item(), lxy.item(), lwh.item(), lconf.item( ), lcls.item(), nT else: if ONNX_EXPORT: grid_xy = self.grid_xy.repeat((1, self.nA, 1, 1, 1)).view( (1, -1, 2)) anchor_wh = self.anchor_wh.repeat((1, 1, nG, nG, 1)).view( (1, -1, 2)) / nG # p = p.view(-1, 85) # xy = xy + self.grid_xy[0] # x, y # wh = torch.exp(wh) * self.anchor_wh[0] # width, height # p_conf = torch.sigmoid(p[:, 4:5]) # Conf # p_cls = F.softmax(p[:, 5:85], 1) * p_conf # SSD-like conf # return torch.cat((xy / nG, wh, p_conf, p_cls), 1).t() p = p.view(1, -1, 85) xy = xy + grid_xy # x, y wh = torch.exp(p[..., 2:4]) * anchor_wh # width, height p_conf = torch.sigmoid(p[..., 4:5]) # Conf p_cls = p[..., 5:85] # Broadcasting only supported on first dimension in CoreML. See onnx-coreml/_operators.py # p_cls = F.softmax(p_cls, 2) * p_conf # SSD-like conf p_cls = torch.exp(p_cls).permute((2, 1, 0)) p_cls = p_cls / p_cls.sum(0).unsqueeze(0) * p_conf.permute( (2, 1, 0)) # F.softmax() equivalent p_cls = p_cls.permute(2, 1, 0) return torch.cat((xy / nG, wh, p_conf, p_cls), 2).squeeze().t() p[..., 0:2] = xy + self.grid_xy # xy p[..., 2:4] = torch.exp(wh) * self.anchor_wh # wh yolo method # p[..., 2:4] = ((wh * 2) ** 2) * self.anchor_wh # wh power method p[..., 4] = torch.sigmoid(p[..., 4]) # p_conf p[..., :4] *= self.stride # reshape from [1, 3, 13, 13, 85] to [1, 507, 85] return p.view(bs, -1, 5 + self.nC)
running_loss = 0.0 dataset.reset() num = 0 correct = 0 for i, data in enumerate(dataset.getbatch()): inputs, labels = data inputs, labels = torch.tensor( inputs, dtype=torch.uint8).cuda(), torch.tensor(labels).cuda() inputs = inputs.float() optimizer.zero_grad() outputs = player(inputs) tmp = torch.argmax(outputs, dim=1) == labels correct += torch.sum(tmp) num += batchsize loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if (i + 1) % print_each == 0: print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / print_each)) print('train_acc: %.2f' % (float(correct) * 100.0 / num)) correct = 0 num = 0 running_loss = 0.0
def calculate_losses(self, input_states, length_masks, input_masks, pooled_outputs, targets): # Intialize total_loss and losses losses = {} total_loss = torch.zeros(1).to(self.gpu_ids['netE']) input_state, length_mask, input_mask, pooled_output, target = [ input_states[0], length_masks[0], input_masks[0], pooled_outputs[0], targets[0] ] if 'maskgmm' in self.args.task_types: # print(pooled_output['maskgmm'].size(), input_mask.size()) pis, mus, sigmas, rhos, qs = self.decode_parameters( pooled_output['maskgmm'], input_mask) losses['mask_gmm'] = self.losses_weights['mask_gmm'] * self.losses[ 'gmm'](input_state[:, :, :2][input_mask[:, :, 0] == 0, ], pis, mus, sigmas, rhos) pis, mus, sigmas, rhos, qs = self.decode_parameters( pooled_output['maskgmm'], 1 - input_mask) losses['rec_gmm'] = self.losses_weights['rec_gmm'] * self.losses[ 'gmm'](input_state[:, :, :2][input_mask[:, :, 0] == 1, ], pis, mus, sigmas, rhos) total_loss = total_loss + losses['mask_gmm'] + losses['rec_gmm'] losses['mask_type'] = self.losses_weights[ 'mask_type'] * self.losses['mask_type']( qs[input_mask[:, :, 2] == 0, :], torch.argmax(input_state[:, :, 2:5], dim=2)[input_mask[:, :, 2] == 0]) losses['rec_type'] = self.losses_weights['rec_type'] * self.losses[ 'mask_type'](qs[input_mask[:, :, 2] == 1, :], torch.argmax(input_state[:, :, 2:5], dim=2)[input_mask[:, :, 2] == 1]) total_loss = total_loss + losses['mask_type'] if 'maskrec' in self.args.task_types: if self.args.input_dim == 6: axis_dim = [0, 1, 5] else: axis_dim = [0, 1] # May be just compute the mask # print((1-input_mask)[0,:,0].sum()) losses['mask_axis'] = self.losses_weights[ 'mask_axis'] * self.losses['mask_axis']( pooled_output['maskrec'][:, :, axis_dim][ input_mask[:, :, axis_dim] == 0], input_state[:, :, axis_dim][input_mask[:, :, axis_dim] == 0]) losses['rec_axis'] = self.losses_weights['rec_axis'] * self.losses[ 'mask_axis'](pooled_output['maskrec'][:, :, axis_dim][ input_mask[:, :, axis_dim] == 1], input_state[:, :, axis_dim][input_mask[:, :, axis_dim] == 1]) total_loss = total_loss + losses['mask_axis'] + losses['rec_axis'] # print(input_states[:, :, 2:5][input_mask[:, :, 2:5] == 0].size()) #*input_mask[:, :, 2:5](Think about Whether to add it) losses['mask_type'] = self.losses_weights[ 'mask_type'] * self.losses['mask_type']( pooled_output['maskrec'][:, :, 2:5][input_mask[:, :, 2] == 0, :], torch.argmax(input_state[:, :, 2:5], dim=2)[input_mask[:, :, 2] == 0]) losses['rec_type'] = self.losses_weights['rec_type'] * self.losses[ 'mask_type']( pooled_output['maskrec'][:, :, 2:5][input_mask[:, :, 2] == 1, :], torch.argmax(input_state[:, :, 2:5], dim=2)[input_mask[:, :, 2] == 1]) total_loss = total_loss + losses['mask_type'] + losses['rec_type'] if 'maskdisc' in self.args.task_types: losses['x_mask_disc'] = self.losses_weights[ 'mask_axis'] * self.losses['mask_disc']( pooled_output['maskdisc'][0][input_mask[:, :, 0] == 0, :], (input_state[:, :, 0][input_mask[:, :, 0] == 0]).to( torch.long)) losses['x_rec_disc'] = self.losses_weights[ 'rec_axis'] * self.losses['mask_disc']( pooled_output['maskdisc'][0][input_mask[:, :, 0] == 1, :], (input_state[:, :, 0][input_mask[:, :, 0] == 1]).to( torch.long)) losses['y_mask_disc'] = self.losses_weights[ 'mask_axis'] * self.losses['mask_disc']( pooled_output['maskdisc'][1][input_mask[:, :, 1] == 0, :], (input_state[:, :, 1][input_mask[:, :, 1] == 0]).to( torch.long)) losses['y_rec_disc'] = self.losses_weights[ 'rec_axis'] * self.losses['mask_disc']( pooled_output['maskdisc'][1][input_mask[:, :, 1] == 1, :], (input_state[:, :, 1][input_mask[:, :, 1] == 1]).to( torch.long)) losses['type_mask_disc'] = self.losses_weights[ 'mask_type'] * self.losses['mask_disc']( pooled_output['maskdisc'][2][input_mask[:, :, 2] == 0, :], (input_state[:, :, 2][input_mask[:, :, 2] == 0]).to( torch.long)) losses['type_rec_disc'] = self.losses_weights[ 'rec_type'] * self.losses['mask_disc']( pooled_output['maskdisc'][2][input_mask[:, :, 2] == 1, :], (input_state[:, :, 2][input_mask[:, :, 2] == 1]).to( torch.long)) total_loss = total_loss + losses['x_mask_disc'] + losses[ 'y_mask_disc'] + losses['type_mask_disc'] + losses[ 'x_rec_disc'] + losses['y_rec_disc'] + losses[ 'type_rec_disc'] if 'sketchclsinput' in self.args.task_types: losses['prediction'] = self.losses_weights[ 'prediction'] * self.losses['prediction']( pooled_output['sketchclsinput'], target) total_loss = total_loss + losses['prediction'] if 'sketchretrieval' in self.args.task_types: losses['triplet'] = self.losses_weights['triplet'] * self.losses[ 'triplet'](*[ pooled_output['sketchretrieval'] for pooled_output in pooled_outputs ]) total_loss = total_loss + losses['triplet'] return total_loss, losses
def main(args): device = torch.device('cuda' if args.gpu else 'cpu') # Load pretrained model and tokenizer config_cls, model_cls, tokenizer_cls = MODEL_CLASSES[args.model_type] config = config_cls.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, num_labels=args.num_labels, ) tokenizer = tokenizer_cls.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case, ) model = model_cls.from_pretrained( args.model_name_or_path, config=config, ) model.to(device) text_field = TextField(tokenizer) label_field = LabelField( torch.long if args.num_labels > 1 else torch.float) if args.do_test: fields = [('src', text_field), ('ref', text_field)] else: fields = [('src', text_field), ('ref', text_field), ('score', label_field)] # Training if args.do_train: # setup dataset print('Loading training data ...') train_data = Dataset( path_to_file=args.data, fields=fields, filter_pred=lambda ex: args.src_min <= len(ex.src) <= args.src_max \ and args.ref_min <= len(ex.ref) <= args.ref_max ) train_iter = Iterator( dataset=train_data, batch_size=args.batch_size, shuffle=True, repeat=False, ) train(args, train_iter, model, device) model.save_pretrained(args.save_dir) tokenizer.save_pretrained(args.save_dir) # Evaluaiton if args.do_eval: model.eval() # setup dataset print('Loading development data ...') valid_data = Dataset( path_to_file=args.data, fields=fields, filter_pred=lambda ex: args.src_min <= len(ex.src) <= args.src_max \ and args.ref_min <= len(ex.ref) <= args.ref_max ) valid_iter = Iterator( dataset=valid_data, batch_size=args.batch_size, shuffle=True, repeat=False, ) preds_list = [] refs_list = [] for batch in tqdm(valid_iter, total=len(valid_iter)): input_ids = torch.cat([batch.src, batch.ref[:, 1:]], dim=1).to(device) labels = batch.score.squeeze(1).to(device) token_type_ids = [ torch.zeros_like(batch.src), torch.ones_like(batch.ref[:, 1:]) ] token_type_ids = torch.cat(token_type_ids, dim=1).to(device) outputs = model(input_ids, token_type_ids=token_type_ids, labels=labels)[1] if args.num_labels > 1: preds = torch.argmax(outputs, dim=1) else: preds = torch.ge(outputs, args.threshold).int().squeeze(1) preds_list.append(preds.to('cpu')) refs_list.append(labels.int().to('cpu')) preds_list = torch.cat(preds_list) refs_list = torch.cat(refs_list) avg = 'macro' if args.num_labels > 1 else 'micro' precision = precision_score(refs_list, preds_list, average=avg) recall = recall_score(refs_list, preds_list, average=avg) f1 = f1_score(refs_list, preds_list, average=avg) print(f"Presion: {precision * 100}", end='\t') print(f"Recall: {recall * 100}", end='\t') print(f"F1 score: {f1 * 100}") if args.do_test: model.eval() # setup dataset print('Loading test data ...') test_data = Dataset( path_to_file=args.data, fields=fields, filter_pred=lambda ex: args.src_min <= len(ex.src) <= args.src_max \ and args.ref_min <= len(ex.ref) <= args.ref_max ) test_iter = Iterator( dataset=test_data, batch_size=args.batch_size, shuffle=True, repeat=False, ) for batch in tqdm(test_iter, total=len(test_iter)): input_ids = torch.cat([batch.src, batch.ref[:, 1:]], dim=1).to(device) token_type_ids = [ torch.zeros_like(batch.src), torch.ones_like(batch.ref[:, 1:]) ] token_type_ids = torch.cat(token_type_ids, dim=1).to(device) outputs = model(input_ids, token_type_ids=token_type_ids)[0] for src, ref, out in zip(batch.src, batch.ref, outputs): src = src[1:src.tolist().index(tokenizer.sep_token_id)] ref = ref[1:ref.tolist().index(tokenizer.sep_token_id)] src = tokenizer.decode(src) ref = tokenizer.decode(ref) if args.num_labels > 1: out = torch.argmax(out) print(src + '\t' + ref + '\t' + str(out.item()))
def main(): parser = argparse.ArgumentParser() # Required parameters parser.add_argument( "--option", default=None, type=str, required=True, help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()), ) parser.add_argument( "--output_dir", default=None, type=str, help= "The output directory where the model checkpoints and predictions will be written.", ) parser.add_argument( "--model_type", default='bert', type=str, help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()), ) parser.add_argument( "--model_name_or_path", default="bert-base-uncased", type=str, help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS), ) parser.add_argument( "--max_seq_length", default=128, type=int, help= "The maximum total input sequence length after WordPiece tokenization. Sequences " "longer than this will be truncated, and sequences shorter than this will be padded.", ) parser.add_argument("--weight_decay", default=0.0, type=float, help="Weight decay if we apply some.") parser.add_argument("--adam_epsilon", default=1e-8, type=float, help="Epsilon for Adam optimizer.") parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") parser.add_argument("--num_train_epochs", default=3.0, type=float, help="Total number of training epochs to perform.") parser.add_argument( "--train_file", default=None, type=str, help= "The input training file. If a data dir is specified, will look for the file there" + "If no data dir or train/predict files are specified, will run with tensorflow_datasets.", ) parser.add_argument("--logging_steps", type=int, default=50, help="Log every X updates steps.") parser.add_argument("--save_steps", type=int, default=5000, help="Save checkpoint every X updates steps.") parser.add_argument("--local_rank", type=int, default=-1, help="local_rank for distributed training on gpus") parser.add_argument( "--predict_file", default=None, type=str, help= "The input evaluation file. If a data dir is specified, will look for the file there" + "If no data dir or train/predict files are specified, will run with tensorflow_datasets.", ) parser.add_argument( "--gradient_accumulation_steps", type=int, default=1, help= "Number of updates steps to accumulate before performing a backward/update pass.", ) parser.add_argument( "--resource_dir", type=str, default='WikiTables-WithLinks/', help= "Number of updates steps to accumulate before performing a backward/update pass.", ) parser.add_argument("--learning_rate", default=5e-5, type=float, help="The initial learning rate for Adam.") parser.add_argument("--seed", type=int, default=42, help="random seed for initialization") parser.add_argument( "--config_name", default="", type=str, help="Pretrained config name or path if not the same as model_name") parser.add_argument( "--do_lower_case", action="store_true", help="Set this flag if you are using an uncased model.") parser.add_argument( "--tokenizer_name", default="", type=str, help="Pretrained tokenizer name or path if not the same as model_name", ) parser.add_argument( "--cache_dir", default="/tmp/", type=str, help= "Where do you want to store the pre-trained models downloaded from s3", ) parser.add_argument( "--stage1_model", default=None, type=str, help="Where to load the trained model from", ) parser.add_argument( "--stage2_model", default=None, type=str, help="Where to load the trained model from", ) parser.add_argument( "--dim", default=None, type=int, help="Where to load the trained model from", ) parser.add_argument("--warmup_steps", default=0, type=int, help="Linear warmup over warmup_steps.") parser.add_argument( "--fp16", action="store_true", help= "Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit", ) parser.add_argument( "--fp16_opt_level", type=str, default="O1", help= "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']." "See details at https://nvidia.github.io/apex/amp.html", ) parser.add_argument("--do_train", action="store_true", help="Whether to run training.") parser.add_argument("--do_eval", action="store_true", help="Whether to run eval on the dev set.") parser.add_argument( "--gpu_index", default=0, type=int, help="gpu_index", ) args = parser.parse_args() device = torch.device("cuda:{}".format(args.gpu_index)) args.n_gpu = 1 args.device = device if args.do_train: args.output_dir = args.option args.output_dir = os.path.join( args.output_dir, datetime.now().strftime('%Y_%m_%d_%H_%M_%S')) else: assert args.output_dir != None or ( args.stage1_model and args.stage2_model), "You must set an output dir" # Setup logging logging.basicConfig( format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", datefmt="%m/%d/%Y %H:%M:%S", level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN, ) # Set seed set_seed(args) args.model_type = args.model_type.lower() config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type] config = config_class.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, cache_dir=args.cache_dir if args.cache_dir else None, ) tokenizer = tokenizer_class.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case, cache_dir=args.cache_dir if args.cache_dir else None, ) args.dim = config.hidden_size if args.option in ['stage1', 'stage2']: if args.option == 'stage1': model = FilterModel(model_class, args.model_name_or_path, config, args.cache_dir, dim=args.dim) model.to(args.device) else: model = JumpModel(model_class, args.model_name_or_path, config, args.cache_dir, dim=args.dim) model.to(args.device) elif args.option == 'stage12': filter_model = FilterModel(model_class, args.model_name_or_path, config, args.cache_dir, dim=args.dim) filter_model.to(args.device) jump_model = JumpModel(model_class, args.model_name_or_path, config, args.cache_dir, dim=args.dim) jump_model.to(args.device) else: raise NotImplementedError logger.info("Training/evaluation parameters %s", args) if args.do_train: train_data = readGZip(args.train_file) dataset = Stage12Dataset(args.resource_dir, train_data, tokenizer, args.max_seq_length, args.option, retain_label=True, shuffle=True) loader = DataLoader(dataset, batch_size=None, batch_sampler=None, num_workers=0, shuffle=False, pin_memory=True) # tb_writer = SummaryWriter(log_dir=args.output_dir) # Prepare optimizer and schedule (linear warmup and decay) no_decay = ["bias", "LayerNorm.weight"] optimizer_grouped_parameters = [ { "params": [ p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay) ], "weight_decay": args.weight_decay, }, { "params": [ p for n, p in model.named_parameters() if any(nd in n for nd in no_decay) ], "weight_decay": 0.0 }, ] optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon) t_total = len( train_data ) // args.gradient_accumulation_steps * args.num_train_epochs scheduler = get_linear_schedule_with_warmup( optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total) # Check if saved optimizer or scheduler states exist if os.path.isfile(os.path.join( args.model_name_or_path, "optimizer.pt")) and os.path.isfile( os.path.join(args.model_name_or_path, "scheduler.pt")): # Load in optimizer and scheduler states optimizer.load_state_dict( torch.load( os.path.join(args.model_name_or_path, "optimizer.pt"))) scheduler.load_state_dict( torch.load( os.path.join(args.model_name_or_path, "scheduler.pt"))) if args.fp16: try: from apex import amp except ImportError: raise ImportError( "Please install apex from https://www.github.com/nvidia/apex to use fp16 training." ) model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level) # multi-gpu training (should be after apex fp16 initialization) if args.n_gpu > 1: model = torch.nn.DataParallel(model) global_step = 0 tr_loss, logging_loss = 0.0, 0.0 model.train() model.zero_grad() train_iterator = trange(0, int(args.num_train_epochs), desc="Epoch") for epoch in train_iterator: for step, batch in enumerate(tqdm(loader, desc="Iteration")): *data, labels = tuple( Variable(t).to(args.device) for t in batch) probs = model(*data) loss = torch.sum(-torch.log(probs + 1e-8) * labels) if args.fp16: with amp.scale_loss(loss, optimizer) as scaled_loss: scaled_loss.backward() else: loss.backward() tr_loss += loss.item() if (step + 1) % args.gradient_accumulation_steps == 0: if args.fp16: torch.nn.utils.clip_grad_norm_( amp.master_params(optimizer), args.max_grad_norm) else: torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm) optimizer.step() scheduler.step() # Update learning rate schedule model.zero_grad() global_step += 1 # Log metrics # if args.logging_steps > 0 and global_step % args.logging_steps == 0: # # Only evaluate when single GPU otherwise metrics may not average well # #if args.local_rank == -1 and args.evaluate_during_training: # # results = evaluate(args, model, tokenizer) # # for key, value in results.items(): # # tb_writer.add_scalar("eval_{}".format(key), value, global_step) # tb_writer.add_scalar("{}_lr".format(args.option), scheduler.get_last_lr()[0], global_step) # tb_writer.add_scalar("{}_loss".format(args.option), (tr_loss - logging_loss) / args.logging_steps, global_step) # logging_loss = tr_loss # Save model checkpoint output_dir = os.path.join(args.output_dir, "checkpoint-epoch{}".format(epoch)) if not os.path.exists(output_dir): os.makedirs(output_dir) # Take care of distributed/parallel training model_to_save = model.module if hasattr(model, "module") else model model_to_save.save_pretrained(output_dir) tokenizer.save_pretrained(output_dir) torch.save(args, os.path.join(output_dir, "training_args.bin")) # tb_writer.close() if args.do_eval and args.option in ['stage1', 'stage2']: dev_data = readGZip(args.predict_file) model.eval() dataset = Stage12Dataset(args.resource_dir, dev_data, tokenizer, args.max_seq_length, args.option, retain_label=True, shuffle=False) loader = DataLoader(dataset, batch_size=None, batch_sampler=None, num_workers=8, shuffle=False, pin_memory=True) for model_path in os.listdir(args.output_dir): if model_path.startswith('checkpoint'): model.load_state_dict( torch.load( os.path.join(args.output_dir, model_path, 'pytorch_model.bin'))) logger.info("Loading model from {}".format(model_path)) eval_loss = 0 for step, batch in enumerate(tqdm(loader, desc="Evaluation")): *data, labels = tuple( Variable(t).to(args.device) for t in batch) probs = model(*data) loss = torch.sum(-torch.log(probs + 1e-8) * labels) eval_loss += loss.item() eval_loss = eval_loss / len(loader) logger.info("{} acheives average loss = {}".format( model_path, eval_loss)) elif args.do_eval and args.option == 'stage12': dev_data = readGZip(args.predict_file) # multi-gpu training (should be after apex fp16 initialization) filter_model.eval() jump_model.eval() #assert args.model_name_or_path is not None, "please provide the load_from argument" model_path = os.path.join(args.stage1_model, 'pytorch_model.bin') filter_model.load_state_dict(torch.load(model_path)) model_path = os.path.join(args.stage2_model, 'pytorch_model.bin') jump_model.load_state_dict(torch.load(model_path)) pred_data = copy.copy(dev_data) succ, total = 0, 0 dataset = Stage12Dataset(args.resource_dir, dev_data, tokenizer, args.max_seq_length, 'stage1', retain_label=False, shuffle=False) loader = DataLoader(dataset, batch_size=None, batch_sampler=None, num_workers=8, shuffle=False, pin_memory=True) for step, batch in enumerate(tqdm(loader, desc="Evaluation")): data = tuple(Variable(t).to(args.device) for t in batch[:-1]) probs = filter_model(*data) info = dev_data[batch[-1]] info['nodes'] = [info['nodes'][torch.argmax(probs, 0).item()]] info = generate_target_nodes(args.resource_dir, info) selected_target_nodes = [] inner_dataset = Stage12Dataset(args.resource_dir, info, tokenizer, args.max_seq_length, 'stage2', retain_label=False, shuffle=False) for b in inner_dataset: data = tuple(Variable(t).to(args.device) for t in b[:-1]) probs = jump_model(*data) tmp = info[b[-1]]['target'] selected_target_nodes.append(tmp[torch.argmax(probs, 0).item()]) discovered_node = selected_target_nodes[0] pred_data[step]['target'] = discovered_node if not discovered_node[2]: pred_data[step]['pred'] = discovered_node[0] else: pred_data[step]['pred'] = [ discovered_node[0], discovered_node[2] ] #print("FINAL: correct = {}, total = {}, correct rate = {} \n".format(succ, total, succ / total)) with open('predictions.intermediate.json', 'w') as f: json.dump(pred_data, f, indent=2)
def select_hardest(loss_values, margin=None): if loss_values.max() == 0: return None return torch.argmax(loss_values)
def predict(self, x): outputs = self.forward(x) return torch.argmax(F.softmax(outputs).data, 1)
optimizer.zero_grad() # forward + backward + optimize # outputs = net(inputs) outputs = model(inputs) # print(outputs.shape) # print(outputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() scheduler.step() # print statistics running_loss += loss.item() if i % p_itr == p_itr-1: # print every 2000 mini-batches pred = torch.argmax(outputs, dim=1) correct = pred.eq(labels) acc = torch.mean(correct.float()) loss_list.append(running_loss/p_itr) acc_list.append(acc) print('[%d, %5d] loss: %.3f,' % (epoch + 1, i + 1, running_loss / p_itr), f'ETA: {eta} seconds') # print(f'ETA: {eta} seconds') running_loss = 0.0 t1_stop = process_time() total_iters = total_epoch*len(trainloader) remaining_iters = (total_epoch-epoch + 1)*(len(trainloader) - i + 1)+0.01 eta = (t1_stop-t1_start)/(total_iters-remaining_iters)*(remaining_iters) last_t1_stop = t1_stop t1_stop = process_time() plt.plot(loss_list, label='loss')
hidden=hidden, maxlen=maxlen, sample=False, mask=mask_ARAE, avoid_l=args.avoid_l) decoded = torch.stack(decoded, dim=1).float() if n_repeat > 1: decoded = torch.repeat_interleave(decoded, repeats=n_repeat, dim=0) decoded_prob = F.softmax(decoded, dim=-1) decoded_prob = one_hot_prob(decoded_prob, max_indices) sen_idxs = torch.argmax(decoded_prob, dim=2) sen_idxs = sen_idxs.cpu().numpy() output_s = list() glue = ' ' sentence_list = list() for ss in sen_idxs: sentence = [ARAE_idx2word[s] for s in ss] trigger_token_ids = list() last_word = None last_word2 = None contain_sentiment_word = False new_sentence = list() for word in sentence: cur_idx = snli_vocab.get_token_index(word)
def get_target(self, l, targets, anchors, in_h, in_w): #-----------------------------------------------------# # 计算一共有多少张图片 #-----------------------------------------------------# bs = len(targets) #-----------------------------------------------------# # 用于选取哪些先验框不包含物体 #-----------------------------------------------------# noobj_mask = torch.ones(bs, len(self.anchors_mask[l]), in_h, in_w, requires_grad=False) #-----------------------------------------------------# # 让网络更加去关注小目标 #-----------------------------------------------------# box_loss_scale = torch.zeros(bs, len(self.anchors_mask[l]), in_h, in_w, requires_grad=False) #-----------------------------------------------------# # batch_size, 3, 13, 13, 5 + num_classes #-----------------------------------------------------# y_true = torch.zeros(bs, len(self.anchors_mask[l]), in_h, in_w, self.bbox_attrs, requires_grad=False) for b in range(bs): if len(targets[b]) == 0: continue batch_target = torch.zeros_like(targets[b]) #-------------------------------------------------------# # 计算出正样本在特征层上的中心点 #-------------------------------------------------------# batch_target[:, [0, 2]] = targets[b][:, [0, 2]] * in_w batch_target[:, [1, 3]] = targets[b][:, [1, 3]] * in_h batch_target[:, 4] = targets[b][:, 4] batch_target = batch_target.cpu() #-------------------------------------------------------# # 将真实框转换一个形式 # num_true_box, 4 #-------------------------------------------------------# gt_box = torch.FloatTensor( torch.cat((torch.zeros( (batch_target.size(0), 2)), batch_target[:, 2:4]), 1)) #-------------------------------------------------------# # 将先验框转换一个形式 # 9, 4 #-------------------------------------------------------# anchor_shapes = torch.FloatTensor( torch.cat((torch.zeros( (len(anchors), 2)), torch.FloatTensor(anchors)), 1)) #-------------------------------------------------------# # 计算交并比 # self.calculate_iou(gt_box, anchor_shapes) = [num_true_box, 9]每一个真实框和9个先验框的重合情况 # best_ns: # [每个真实框最大的重合度max_iou, 每一个真实框最重合的先验框的序号] #-------------------------------------------------------# best_ns = torch.argmax(self.calculate_iou(gt_box, anchor_shapes), dim=-1) for t, best_n in enumerate(best_ns): if best_n not in self.anchors_mask[l]: continue #----------------------------------------# # 判断这个先验框是当前特征点的哪一个先验框 #----------------------------------------# k = self.anchors_mask[l].index(best_n) #----------------------------------------# # 获得真实框属于哪个网格点 #----------------------------------------# i = torch.floor(batch_target[t, 0]).long() j = torch.floor(batch_target[t, 1]).long() #----------------------------------------# # 取出真实框的种类 #----------------------------------------# c = batch_target[t, 4].long() #----------------------------------------# # noobj_mask代表无目标的特征点 #----------------------------------------# noobj_mask[b, k, j, i] = 0 #----------------------------------------# # tx、ty代表中心调整参数的真实值 #----------------------------------------# y_true[b, k, j, i, 0] = batch_target[t, 0] y_true[b, k, j, i, 1] = batch_target[t, 1] y_true[b, k, j, i, 2] = batch_target[t, 2] y_true[b, k, j, i, 3] = batch_target[t, 3] y_true[b, k, j, i, 4] = 1 y_true[b, k, j, i, c + 5] = 1 #----------------------------------------# # 用于获得xywh的比例 # 大目标loss权重小,小目标loss权重大 #----------------------------------------# box_loss_scale[ b, k, j, i] = batch_target[t, 2] * batch_target[t, 3] / in_w / in_h return y_true, noobj_mask, box_loss_scale
# %% Load packages import numpy as np import torch from sklearn.metrics import accuracy_score from bnn_mcmc_examples.examples.mlp.penguins.constants import num_chains from bnn_mcmc_examples.examples.mlp.penguins.dataloaders import test_dataloader from bnn_mcmc_examples.examples.mlp.penguins.prior.constants import sampler_output_path, sampler_output_run_paths # %% Load test data and labels _, test_labels = next(iter(test_dataloader)) # %% Compute predictive accuracies accuracies = np.empty(num_chains) for i in range(num_chains): test_preds = np.loadtxt( sampler_output_run_paths[i].joinpath('preds_via_mean.txt'), skiprows=0) accuracies[i] = accuracy_score(test_preds, torch.argmax(test_labels, 1)) # %% Save predictive accuracies np.savetxt(sampler_output_path.joinpath('accuracies_via_mean.txt'), accuracies)
inputs = t.squeeze(inputs, axis=1) inputs, labels = inputs.cuda(), labels.cuda() state_h = t.zeros(size=(batch_size, hidden_size), device=device) state_c = t.zeros(size=(batch_size, hidden_size), device=device) for ts in range(timestep): input_t = inputs[:, ts, :] f_t = t.sigmoid( t.matmul(input_t, kernel_f) + t.matmul(state_h, recurrent_kernel_f) + bias_f) i_t = t.sigmoid( t.matmul(input_t, kernel_i) + t.matmul(state_h, recurrent_kernel_i) + bias_i) o_t = t.sigmoid( t.matmul(input_t, kernel_o) + t.matmul(state_h, recurrent_kernel_o) + bias_o) c_t_hat = t.tanh( t.matmul(input_t, kernel_c) + t.matmul(state_h, recurrent_kernel_c) + bias_c) state_c = t.mul(state_c, f_t) + t.mul(c_t_hat, i_t) state_h = t.mul(t.tanh(state_c), o_t) logits = t.matmul(state_h, dense_weight) + dense_bias sfm = nn.Softmax(dim=1) pred = t.argmax(sfm(logits), dim=1) correct = t.sum(pred == labels) correct_count += correct total_count += inputs.shape[0] print("test set accuracy = %f" % (correct_count / total_count))
running_loss += loss.item() # 计算准确率 model.eval() # 推论模式 with torch.no_grad(): y_true = [] y_pred = [] for batch in dev_loader: batch = tuple(t.to(device) for t in batch) input_ids, input_mask, segment_ids, label_ids = batch outputs = model(input_ids=input_ids, token_type_ids=segment_ids, attention_mask=input_mask) logits = outputs[0] logits = torch.argmax(F.log_softmax(logits, dim=2), dim=2) logits = logits.detach().cpu().numpy() label_ids = label_ids.to('cpu').numpy() input_mask = input_mask.to('cpu').numpy() for i, label in enumerate(label_ids): temp_1 = [] temp_2 = [] # 第i个句子 第j个字, 剔除第一个[cls] for j, m in enumerate(label): if j == 0: continue elif label_ids[i][j] == len(label_map): y_true.append(temp_1) y_pred.append(temp_2)
def forward(self, raw: dict, img_size, labels=None): assert isinstance(raw, dict) t_xywha = raw['bbox'] device = t_xywha.device nB = t_xywha.shape[0] # batch size nA = self.num_anchors # number of anchors nH, nW = t_xywha.shape[2:4] # prediction grid size assert t_xywha.shape[1] == nA and t_xywha.shape[-1] == 5 conf_logits = raw['conf'] cls_logits = raw['class'] # Convert the predicted angle to radian for later use. p_radian = torch.sigmoid(t_xywha[..., 4]) * 2 * np.pi - np.pi # ----------------------- logits to prediction ----------------------- p_xywha = t_xywha.detach().clone() p_xywha: torch.tensor # sigmoid activation for xy, angle, obj_conf y_ = torch.arange(nH, dtype=torch.float, device=device) x_ = torch.arange(nW, dtype=torch.float, device=device) mesh_y, mesh_x = torch.meshgrid(y_, x_) p_xywha[..., 0] = (torch.sigmoid(p_xywha[..., 0]) + mesh_x) * self.stride p_xywha[..., 1] = (torch.sigmoid(p_xywha[..., 1]) + mesh_y) * self.stride # w, h anch_wh = self.anchors.view(1,nA,1,1,2).to(device=device) p_xywha[..., 2:4] = torch.exp(p_xywha[..., 2:4]) * anch_wh p_xywha[..., 4] = p_radian / np.pi * 180 p_xywha = p_xywha.cpu().contiguous() # Logistic activation for confidence score p_conf = torch.sigmoid(conf_logits.detach()) # Logistic activation for categories if self.n_cls > 0: p_cls = torch.sigmoid(cls_logits.detach()) cls_score, cls_idx = torch.max(p_cls, dim=-1, keepdim=True) p_conf = torch.sqrt(p_conf * cls_score) cls_idx = cls_idx.view(nB, nA*nH*nW).cpu() else: cls_idx = torch.zeros(nB, nA*nH*nW, dtype=torch.int64) preds = { 'bbox': p_xywha.view(nB, nA*nH*nW, 5), 'class_idx': cls_idx, 'score': p_conf.view(nB, nA*nH*nW).cpu(), } if labels is None: return preds, None assert isinstance(labels, list) self.valid_gts = [] # Initialize prediction targets PositiveMask = torch.zeros(nB, nA, nH, nW, dtype=torch.bool) IgnoredMask = torch.zeros(nB, nA, nH, nW, dtype=torch.bool) weighted = torch.zeros(nB, nA, nH, nW) TargetXYWH = torch.zeros(nB, nA, nH, nW, 4) TargetAngle = torch.zeros(nB, nA, nH, nW) TargetConf = torch.zeros(nB, nA, nH, nW, 1) if self.n_cls > 0: TargetCls = torch.zeros(nB, nA, nH, nW, self.n_cls) # traverse all images in a batch for b in range(nB): im_labels = labels[b] assert isinstance(im_labels, ImageObjects) assert im_labels._bb_format == 'cxcywhd' assert im_labels.img_hw == img_size im_labels.sanity_check() nGT = len(im_labels) # if there is no ground truth, continue if nGT == 0: continue gt_bboxes = im_labels.bboxes gt_cls_idxs = im_labels.cats assert gt_bboxes.shape[1] == 5 # (cx, cy, w, h, degree) # IoU between all predicted bounding boxes and all GT. # rot bbox IoU calculation is expensive so only calculate IoU # using confident samples selected_idx = conf_logits[b] > - np.log(1/(0.005) - 1) selected_idx = selected_idx.squeeze(-1) p_selected = p_xywha[b][selected_idx] # if all predictions are lower than 0.005, penalize everything # if too many preictions are higher than 0.005, penalize everything if len(p_selected) < 1000 and len(p_selected) > 0: pred_ious = iou_rle(p_selected.view(-1,5), gt_bboxes, bb_format='cxcywhd', img_size=img_size) iou_with_gt, _ = pred_ious.max(dim=1) # do not penalize the predicted bboxes who have a high overlap # with any GT IgnoredMask[b, selected_idx] = (iou_with_gt > self.ignore_thre) # conf_loss_mask == 1 means give penalty for gi, (gt_bb, gt_cidx) in enumerate(zip(gt_bboxes, gt_cls_idxs)): assert gt_bb.dim() == 1 and len(gt_bb) == 5 _gt_00wh0 = gt_bb.clone() _gt_00wh0[0:2] = 0 _gt_00wh0[4] = 0 _gt_00wh0 = _gt_00wh0.unsqueeze(0) anchor_ious = iou_rle(_gt_00wh0, self.anch_00wha_all, bb_format='cxcywhd', img_size=img_size) anch_idx_all = torch.argmax(anchor_ious, dim=1).squeeze().item() if not (self.anchor_indices == anch_idx_all).any(): # this layer is not responsible for this GT continue self.valid_gts.append(gt_bb.clone()) ta = anch_idx_all % nA # target anchor index ti = (gt_bb[0] / self.stride).long() # horizontal tj = (gt_bb[1] / self.stride).long() # vertical # positive sample PositiveMask[b,ta,tj,ti] = True # target x, y TargetXYWH[b,ta,tj,ti,0] = (gt_bb[0] / self.stride) % 1 TargetXYWH[b,ta,tj,ti,1] = (gt_bb[1] / self.stride) % 1 TargetXYWH[b,ta,tj,ti,2] = torch.log(gt_bb[2]/self.anchors[ta,0] + 1e-8) TargetXYWH[b,ta,tj,ti,3] = torch.log(gt_bb[3]/self.anchors[ta,1] + 1e-8) # use radian when calculating angle loss TargetAngle[b,ta,tj,ti] = gt_bb[4] / 180 * np.pi # target confidence score TargetConf[b,ta,tj,ti] = 1 # target category if self.n_cls > 0: TargetCls[b, ta, tj, ti, gt_cidx] = 1 # smaller objects have higher losses img_area = img_size[0] * img_size[1] weighted[b,ta,tj,ti] = 2 - gt_bb[2] * gt_bb[3] / img_area # move the tagerts to GPU PositiveMask = PositiveMask.to(device=device) IgnoredMask = IgnoredMask.to(device=device) TargetXYWH = TargetXYWH.to(device=device) TargetAngle = TargetAngle.to(device=device) TargetConf = TargetConf.to(device=device) if self.n_cls > 0: TargetCls = TargetCls.to(device=device) weighted = weighted.unsqueeze(-1).to(device=device)[PositiveMask] bce_logits = tnf.binary_cross_entropy_with_logits # weighted *BCE* loss for xy _pxy = t_xywha[...,0:2][PositiveMask] _tgtxy = TargetXYWH[...,0:2][PositiveMask] loss_xy = bce_logits(_pxy, _tgtxy, weight=weighted, reduction='sum') # weighted loss for w,h _pwh = t_xywha[...,2:4][PositiveMask] _tgtwh = TargetXYWH[...,2:4][PositiveMask] # loss_wh = 0.5 * (weighted * (_pwh - _tgtwh).pow(2)).sum() weighted = torch.cat([weighted,weighted], dim=1) loss_wh = lossLib.smooth_L1_loss(_pwh, _tgtwh, beta=self.wh_sl1_beta, weight=weighted, reduction='sum') # loss for angle loss_angle = self.loss4angle(p_radian[PositiveMask], TargetAngle[PositiveMask]) # confidence score _penalty = PositiveMask | (~IgnoredMask) loss_conf = bce_logits(conf_logits[_penalty], TargetConf[_penalty], reduction='sum') if self.n_cls > 0: loss_cls = bce_logits(cls_logits[PositiveMask], TargetCls[PositiveMask], reduction='sum') else: loss_cls = 0 loss = loss_xy + loss_wh + loss_angle + loss_conf + loss_cls loss = loss / nB # logging pos_num = PositiveMask.sum().cpu().item() ngt = pos_num + 1e-16 ignored_num = (IgnoredMask & (~PositiveMask)).sum().cpu().item() self.loss_str = f'level_{nH}x{nW} pos/ignore: {int(ngt)}/{ignored_num}, loss: ' \ f'xy/gt {loss_xy/ngt:.3f}, wh/gt {loss_wh/ngt:.3f}, ' \ f'angle/gt {loss_angle/ngt:.3f}, conf {loss_conf:.3f}, ' \ f'class {loss_cls:.3f}' self._assigned_num = pos_num return preds, loss
train_X = X[:train_size] train_y = y[:train_size] test_X = X[train_size:] test_y = y[train_size:] print("Start to train...") for epoch in range(EPOCHS): for i in tqdm(range(0, len(train_X), BATCH_SIZE)): batch_x = train_X[i:i + BATCH_SIZE].view(-1, 3, 227, 227) batch_y = train_y[i:i + BATCH_SIZE] net.zero_grad() outputs = net(batch_x) loss = loss_function(outputs, batch_y) loss.backward() optimizer.step() correct = 0 total = 0 print("Start to predict...") with torch.no_grad(): for i in tqdm(range(len(test_X))): real_class = torch.argmax(test_y[i]) net_out = net(test_X[i].view(-1, 3, 227, 227))[0] predicted_class = torch.argmax(net_out) if real_class == predicted_class: correct += 1 total += 1 print("AlexNet Accuracy: ", round(correct / total, 3))
def forward(self, synonymy_scores, antonymy_scores, labels): correct_syn = 0 wrong_syn = 0 correct_ant = 0 wrong_ant = 0 correct_irrel = 0 wrong_irrel = 0 syn_size = 0 ant_size = 0 irrel_size = 0 for label, syn_sc, ant_sc in zip(labels, synonymy_scores, antonymy_scores): total_vec = torch.cat((syn_sc, ant_sc), dim=0) probs = F.log_softmax(total_vec, dim=0) #class probability pred = torch.argmax(probs, dim=0) #predicted class if syn_sc <= 0.4 and ant_sc <= 0.4: pred = 2 #word pair is synonymous if label == 1: syn_size += 1 if pred == 0: correct_syn += 1 else: wrong_syn += 1 #word pair is antonymous if label == 2: ant_size += 1 if pred == 1: correct_ant += 1 else: wrong_ant += 1 #word pair has no relationship if label == 0: irrel_size += 1 if pred == 2: correct_irrel += 1 else: wrong_irrel += 1 #need to account for division by zero in training batches if syn_size == 0: syn_acc = 0 else: syn_acc = (correct_syn / syn_size) * 100 if ant_size == 0: ant_acc = 0 else: ant_acc = (correct_ant / ant_size) * 100 if irrel_size == 0: irrel_acc = 0 else: irrel_acc = (correct_irrel / irrel_size) * 100 return [syn_acc, ant_acc, irrel_acc]
def accuracy(out, labels): outputs = torch.argmax(out, dim=1) return 100 * torch.sum(outputs==labels).to(dtype=torch.double)/labels.numel()
def valid_model(dataLoader, model, device, label_map, level_label_maps): model.eval() num_levels = label_map.shape[1] num_classes = dataLoader.dataset.get_num_classes() l1_cls_num = label_map[:, 0].max().item() + 1 l2_cls_num = label_map[:, 1].max().item() + 1 virtual_cls_num = l1_cls_num + l2_cls_num - num_classes l1_raw_cls_num = l1_cls_num - virtual_cls_num fusion_matrix1 = FusionMatrix(num_classes) fusion_matrix2 = FusionMatrix(l1_cls_num) func = torch.nn.Softmax(dim=1) # 20 + 80 acc1 = AverageMeter() p1_acc1 = AverageMeter() p2_acc1 = AverageMeter() level_accs = [AverageMeter() for _ in range(num_levels)] all_labels1 = [] all_result1 = [] # 20 + 2 acc2 = AverageMeter() p1_acc2 = AverageMeter() p2_acc2 = AverageMeter() all_labels2 = [] all_result2 = [] with torch.no_grad(): for i, (image, label, meta) in enumerate(dataLoader): image, label = image.to(device), label.to(device) batch_size = label.shape[0] level_scores = [] level_probs = [] for level in range(num_levels): level_score = model(image, level) level_scores.append(level_score) # for each level level_label = label_map[label, level] level_mask = level_label >= 0 level_label1 = level_label[level_mask] level_score1 = level_score[level_mask] level_top1 = torch.argmax(level_score1, 1) level_acc1, level_cnt1 = accuracy(level_top1.cpu().numpy(), level_label1.cpu().numpy()) level_accs[level].update(level_acc1, level_cnt1) if level == 0: level_prob = func(level_score) level_probs.append(level_prob) else: high_lcid_to_curr_lcid = level_label_maps[level - 1] level_prob = torch.zeros(level_score.shape).cuda() for high_lcid in range(high_lcid_to_curr_lcid.shape[0]): curr_lcid_mask = high_lcid_to_curr_lcid[high_lcid] if curr_lcid_mask.sum().item() > 0: level_prob[:, curr_lcid_mask] = func( level_score[:, curr_lcid_mask]) level_probs.append(level_prob) # =================== 20 + 80 ============================ all_probs = torch.ones((batch_size, num_classes)).cuda() for level in range(num_levels): level_prob = level_probs[level] related_lcids = label_map[:, level] related_lcids = related_lcids[related_lcids >= 0] unrelated_class_num1 = (label_map[:, level] < 0).sum().item() unrelated_class_num2 = label_map.shape[ 0] - related_lcids.shape[0] assert unrelated_class_num1 == unrelated_class_num2 all_probs[:, unrelated_class_num1:] *= level_prob[:, related_lcids] l1_mask1 = label < l1_raw_cls_num l1_scores1 = all_probs[l1_mask1] l1_labels1 = label[l1_mask1] l1_result1 = torch.argmax(l1_scores1, 1) l1_now_acc1, l1_cnt1 = accuracy(l1_result1.cpu().numpy(), l1_labels1.cpu().numpy()) p1_acc1.update(l1_now_acc1, l1_cnt1) l2_mask1 = label >= l1_raw_cls_num l2_scores1 = all_probs[l2_mask1] l2_labels1 = label[l2_mask1] l2_result1 = torch.argmax(l2_scores1, 1) l2_now_acc1, l2_cnt1 = accuracy(l2_result1.cpu().numpy(), l2_labels1.cpu().numpy()) p2_acc1.update(l2_now_acc1, l2_cnt1) now_result = torch.argmax(all_probs, 1) now_acc, cnt = accuracy(now_result.cpu().numpy(), label.cpu().numpy()) acc1.update(now_acc, cnt) fusion_matrix1.update(now_result.cpu().numpy(), label.cpu().numpy()) all_labels1.extend(label.cpu().numpy().tolist()) all_result1.extend(now_result.cpu().numpy().tolist()) # ==================================================================== # ===================20 + 2 ================================= l1v_scores = level_probs[0] l1v_labels = label_map[label, 0] l1_mask2 = l1v_labels < l1_raw_cls_num l1_scores2 = l1v_scores[l1_mask2] l1_labels2 = l1v_labels[l1_mask2] l1_result2 = torch.argmax(l1_scores2, 1) l1_now_acc2, l1_cnt2 = accuracy(l1_result2.cpu().numpy(), l1_labels2.cpu().numpy()) p1_acc2.update(l1_now_acc2, l1_cnt2) l2_mask2 = l1v_labels >= l1_raw_cls_num l2_scores2 = l1v_scores[l2_mask2] l2_labels2 = l1v_labels[l2_mask2] l2_result2 = torch.argmax(l2_scores2, 1) l2_now_acc2, l2_cnt2 = accuracy(l2_result2.cpu().numpy(), l2_labels2.cpu().numpy()) p2_acc2.update(l2_now_acc2, l2_cnt2) l1v_result = torch.argmax(l1v_scores, 1) l1v_now_acc, l1v_cnt = accuracy(l1v_result.cpu().numpy(), l1v_labels.cpu().numpy()) acc2.update(l1v_now_acc, l1v_cnt) fusion_matrix2.update(l1v_result.cpu().numpy(), l1v_labels.cpu().numpy()) all_labels2.extend(l1v_labels.cpu().numpy().tolist()) all_result2.extend(l1v_result.cpu().numpy().tolist()) # ==================================================================== print('Acc (head+tail): %.4f %d' % (acc1.avg, acc1.count)) print('Acc P1 : %.4f %d' % (p1_acc1.avg, p1_acc1.count)) print('Acc P2 : %.4f %d' % (p2_acc1.avg, p2_acc1.count)) print('Acc L1 : %.4f %d' % (level_accs[0].avg, level_accs[0].count)) print('Acc L2 : %.4f %d' % (level_accs[1].avg, level_accs[1].count)) print('=' * 23) print('Acc (head+v) : %.4f %d' % (acc2.avg, acc2.count)) print('Acc P1 : %.4f %d' % (p1_acc2.avg, p1_acc2.count)) print('Acc Pv : %.4f %d' % (p2_acc2.avg, p2_acc2.count)) print('=' * 23) return fusion_matrix1, fusion_matrix2, all_labels1, all_result1, all_labels2, all_result2
def train_cp_predictor(model, dataset, lr=1e-3, epochs=7, batch_size=64, cuda=True): images, tgt_padding_masks = dataset min_cp = 2 num_cp = (tgt_padding_masks.shape[1] - 1 - min_cp) - torch.sum(tgt_padding_masks, dim=-1) if cuda: images = images.cuda() num_cp = num_cp.cuda() model = model.cuda() # Separamos en training y validation im_training = images[:40000] im_validation = images[40000:] num_cp_training = num_cp[:40000] num_cp_validation = num_cp[40000:] # Definimos el optimizer optimizer = Adam(model.parameters(), lr=lr) print("Pre-entrenamiento del predictor de num_cp") for epoch in range(epochs): print("Beginning epoch number", epoch + 1) # actual_covariances = cp_covariances * step_decay(cp_variance, epoch, var_drop, epochs_drop, min_variance).to(cp_covariances.device) total_loss = 0 accuracy = 0 for i in range(0, len(im_training) - batch_size + 1, batch_size): # Obtenemos el batch im = im_training[i:i + batch_size] groundtruth = num_cp_training[i: i+batch_size] # Aplicamos el modelo probabilities = model(im) # Calculamos la loss loss = F.cross_entropy(probabilities, groundtruth) # Actualizamos la accuracy y la total_loss accuracy += torch.sum(torch.argmax(probabilities, dim=-1) == groundtruth) total_loss += loss # Realizamos un paso de descenso del gradiente loss.backward() optimizer.step() model.zero_grad() print("EPOCA", epoch+1, "La training loss es", total_loss/40000) print("EPOCA", epoch+1, "La training accuracy es", accuracy/40000) total_loss = 0 accuracy = 0 model.eval() with torch.no_grad(): for j in range(0, len(im_validation) - batch_size + 1, batch_size): # Obtenemos el batch im = im_validation[j:j + batch_size] groundtruth = num_cp_validation[j: j + batch_size] # Aplicamos el modelo probabilities = model(im) # Actualizamos la total_loss total_loss += F.cross_entropy(probabilities, groundtruth) # Actualizamos la accuracy accuracy += torch.sum(torch.argmax(probabilities, dim=-1) == groundtruth) print("EPOCA", epoch + 1, "La validation loss es", total_loss / 10000) print("EPOCA", epoch + 1, "La validation accuracy es", accuracy / 10000) model.train() return model.cpu()
# Predict hidden states features for each layer with torch.no_grad(): # See the models docstrings for the detail of the inputs outputs = model(tokens_tensor, token_type_ids=segments_tensors) # Transformers models always output tuples. # See the models docstrings for the detail of all the outputs # In our case, the first element is the hidden state of the last layer of the Bert model encoded_layers = outputs[0] # We have encoded our input sequence in a FloatTensor of shape (batch size, sequence length, model hidden dimension) assert tuple(encoded_layers.shape) == (1, len(indexed_tokens), model.config.hidden_size) # Load pre-trained model (weights) model = BertForMaskedLM.from_pretrained('bert-base-uncased') model.eval() # If you have a GPU, put everything on cuda tokens_tensor = tokens_tensor.to('cuda') segments_tensors = segments_tensors.to('cuda') model.to('cuda') # Predict all tokens with torch.no_grad(): outputs = model(tokens_tensor, token_type_ids=segments_tensors) predictions = outputs[0] # confirm we were able to predict 'henson' predicted_index = torch.argmax(predictions[0, masked_index]).item() predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0] assert predicted_token == 'henson'
def doEpoch(dl_source, dl_target, model_source, model_target, epoch, optim=None): model_source.eval() model_target.train(optim is not None) mmd = MMD_loss(kernel_type='linear') oa_source_total = 0.0 oa_target_total = 0.0 loss_total = 0.0 def loopDL(dl): while True: for x in iter(dl): yield x num = max(len(dl_source), len(dl_target)) tBar = trange(num) iter_source = loopDL(dl_source) iter_target = loopDL(dl_target) for t in tBar: data_source, labels_source = next(iter_source) data_target, labels_target = next(iter_target) data_source, labels_source = data_source.to(args.device), labels_source.to(args.device) data_target, labels_target = data_target.to(args.device), labels_target.to(args.device) # predict source if args.freezeSource: with torch.no_grad(): pred_source, fVec_source = model_source(data_source, True) elif optim is not None: pred_source, fVec_source = model_target(data_source, True) else: with torch.no_grad(): pred_source, fVec_source = model_target(data_source, True) # predict target if optim is not None: optim.zero_grad() pred_target, fVec_target = model_target(data_target, True) pred_sm_target = F.softmax(pred_target, dim=1) else: with torch.no_grad(): pred_target, fVec_target = model_target(data_target, True) pred_sm_target = F.softmax(pred_target, dim=1) # perform DA if daMethod == 'mmd': loss = mmd(fVec_source, fVec_target) elif daMethod == 'deepcoral': loss = deepCORAL(fVec_source, fVec_target) elif daMethod == 'deepjdot': loss = deepJDOT(fVec_source, fVec_target, labels_source, pred_sm_target) if optim is not None: # source loss if args.trainSource: if args.freezeSource: # re-predict source features with target model pred_source, fVec_source = model_target(data_source, True) loss += F.cross_entropy(pred_source, labels_source) loss.backward() optim.step() with torch.no_grad(): pred_sm_source = F.softmax(pred_source, dim=1) yhat_source = torch.argmax(pred_sm_source, dim=1) yhat_target = torch.argmax(pred_sm_target, dim=1) oa_source_total += torch.sum(labels_source==yhat_source).item() / labels_source.size(0) oa_target_total += torch.sum(labels_target==yhat_target).item() / labels_target.size(0) loss_total += loss.item() tBar.set_description_str('[Ep. {}/{} {}] Loss: {:.2f}, OA source: {:.2f} target: {:.2f}'.format( epoch+1, args.numEpochs, 'train' if optim is not None else 'val', loss_total/(t+1), 100*oa_source_total/(t+1), 100*oa_target_total/(t+1) )) tBar.update(1) tBar.close() loss_total /= num oa_source_total /= num oa_target_total /= num return model_target, loss_total, oa_source_total, oa_target_total
print(device.__repr__()) print(q_network) # TRY NOT TO MODIFY: start the game obs = env.reset() episode_reward = 0 for global_step in range(args.total_timesteps): # ALGO LOGIC: put action logic here epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction*args.total_timesteps, global_step) obs = np.array(obs) logits = q_network.forward(obs.reshape((1,)+obs.shape), device) if args.capture_video: env.set_q_values(logits.tolist()) if random.random() < epsilon: action = env.action_space.sample() else: action = torch.argmax(logits, dim=1).tolist()[0] # TRY NOT TO MODIFY: execute the game and log data. next_obs, reward, done, info = env.step(action) episode_reward += reward # TRY NOT TO MODIFY: record rewards for plotting purposes if 'episode' in info.keys(): print(f"global_step={global_step}, episode_reward={info['episode']['r']}") writer.add_scalar("charts/episode_reward", info['episode']['r'], global_step) writer.add_scalar("charts/epsilon", epsilon, global_step) # TRY NOT TO MODIFY: CRUCIAL step easy to overlook obs = next_obs if done: # important to note that because `EpisodicLifeEnv` wrapper is applied,