def test(epoch): global best_acc net.eval() test_loss = 0 correct = 0 total = 0 with flow.no_grad(): for batch_idx, (torch_inputs, torch_targets) in enumerate(testloader): inputs = flow.tensor(torch_inputs.numpy()) targets = flow.tensor(torch_targets.numpy()) inputs, targets = inputs.to(device), targets.to(device) loss, outputs = resnet18_eval_graph(inputs, targets) # loss = criterion(outputs, targets) test_loss += loss.item() # _, predicted = outputs.max(1) predicted = flow.argmax(outputs, 1).to(flow.int64) total += targets.size(0) correct += predicted.eq(targets).to(flow.int32).sum().item() progress_bar( batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' % (test_loss / (batch_idx + 1), 100. * correct / total, correct, total)) # Save checkpoint. acc = 100. * correct / total if acc > best_acc: print('Saving..') best_acc = acc
def train(epoch): print('\nEpoch: %d' % epoch) net.train() train_loss = 0 correct = 0 total = 0 for batch_idx, (torch_inputs, torch_targets) in enumerate(trainloader): inputs = flow.tensor(torch_inputs.numpy(), requires_grad=False) targets = flow.tensor(torch_targets.numpy(), requires_grad=False) inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() train_loss += loss.item() # _, predicted = outputs.max(1) predicted = flow.argmax(outputs, 1).to(flow.int64) total += targets.size(0) correct += predicted.eq(targets).to(flow.int32).sum().item() progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' % (train_loss/(batch_idx+1), 100.*correct/total, correct, total))
def test(opt): model = DeepQNetwork() pretrain_models = flow.load("{}".format(opt.saved_path)) model.load_state_dict(pretrain_models) model.eval() model.to("cuda") game_state = GameState() image, reward, terminal = game_state.frame_step(0) image = pre_processing( image[:game_state.SCREENWIDTH, :int(game_state.BASEY)], opt.image_size, opt.image_size, ) image = flow.Tensor(image) image = image.to("cuda") state = flow.cat(tuple(image for _ in range(4))).unsqueeze(0) while True: prediction = model(state)[0] action = flow.argmax(prediction).numpy()[0] next_image, reward, terminal = game_state.frame_step(action) next_image = pre_processing( next_image[:game_state.SCREENWIDTH, :int(game_state.BASEY)], opt.image_size, opt.image_size, ) next_image = flow.Tensor(next_image) next_image = next_image.to("cuda") next_state = flow.cat((state[0, 1:, :, :], next_image)).unsqueeze(0) state = next_state
def predict(model, text): model.eval() logits = model(flow.tensor(text)) logits = flow.softmax(logits) label = flow.argmax(logits) return label.numpy(), logits.numpy()
def infer(opt): with open(opt.label_dict, "r") as f: lab_dict = json.load(f) cnn = simple_CNN(opt.num_speakers) cnn.to("cuda") cnn.load_state_dict(flow.load(opt.load_path)) cnn.eval() label_list = lab_dict["test"] err_sum = 0 for wav, label in label_list: inp, lab = example_precess(wav, label) inp = inp.unsqueeze(1) pout = cnn(inp) pred = flow.argmax(pout, dim=1) err = 1 if (pred + 1).numpy() != lab.long().numpy() else 0 err_sum += err print( "wav_filename: ", wav, " predicted speaker id: ", (pred + 1).numpy()[0], " real speaker id: ", lab.long().numpy()[0], ) print("accuracy: ", 1 - err_sum / 6)
def _test_argmax_axis_postive(test_case, device): input = flow.tensor( np.random.randn(2, 6, 5, 3), dtype=flow.float32, device=flow.device(device) ) axis = 1 of_out = flow.argmax(input, dim=axis) np_out = np.argmax(input.numpy(), axis=axis) test_case.assertTrue(np.array_equal(of_out.numpy().flatten(), np_out.flatten()))
def predict(model, text): model.eval() text = flow.tensor(text).to("cuda") text.unsqueeze(0) logits = model(text) logits = flow.softmax(logits) label = flow.argmax(logits) return label.numpy(), logits.numpy()
def train(opt): with open(opt.label_dict, "r") as f: lab_dict = json.load(f) cnn = simple_CNN(opt.num_speakers) cnn.to("cuda") cost = nn.CrossEntropyLoss() cost.to("cuda") optimizer = optim.RMSprop(cnn.parameters(), lr=opt.lr, alpha=opt.alpha, eps=opt.eps) output_folder = opt.output_path N_batches = opt.N_batches N_epoches = opt.N_epoches for epoch in range(N_epoches): cnn.train() loss_sum = 0 err_sum = 0 for i in range(N_batches): inp, lab = create_batches_rnd( lab_dict, batch_size=opt.batch_size, wlen=opt.wlen, fact_amp=opt.fact_amp, train=True, ) inp = inp.unsqueeze(1) lab -= 1 pout = cnn(inp) pred = flow.argmax(pout, dim=1) loss = cost(pout, lab.long()) err = np.mean(pred.numpy() != lab.long().numpy()) loss.backward() optimizer.step() optimizer.zero_grad() loss_sum = loss_sum + loss.detach() err_sum = err_sum + err loss_tot = loss_sum / N_batches err_tot = err_sum / N_batches if epoch % 10 == 0: print("epoch %i, loss_tr=%f err_tr=%f" % (epoch, loss_tot.numpy(), err_tot)) flow.save(cnn.state_dict(), os.path.join(output_folder, "CNN_model"))
def train( model, device, train_data, dev_data, loss_func, optimizer, epochs, train_batch_size, eval_batch_size, save_path, ): global_acc = float("-inf") for i in range(epochs): x_batch, y_batch = batch_loader(train_data[0], train_data[1], train_batch_size) model.train() model.training = True training_loss = 0 all_res, all_ground_truths = [], [] total_correct = 0 total_wrongs = 0 for idx, (data, label) in enumerate( tqdm(zip(x_batch, y_batch), total=len(x_batch))): data = data.to(device) label = label.to(device) logits = model(data) res = flow.argmax(logits, dim=1) total_correct += (res.numpy() == label.numpy()).sum() all_res.append(res) all_ground_truths.append(label) label = flow.tensor(np.eye(2)[label.numpy()], dtype=flow.float32).to(device) loss = loss_func(logits, label) training_loss += loss.numpy() loss.backward() optimizer.step() optimizer.zero_grad() all_ground_truths = flow.cat(all_ground_truths) train_acc = total_correct / len(all_ground_truths.numpy()) acc = _eval(model, dev_data, device, eval_batch_size) if acc > global_acc: global_acc = acc if os.path.exists(save_path): shutil.rmtree(save_path) flow.save(model.state_dict(), save_path) print( f"[Epoch{i}] training loss: {training_loss/(idx+1)} training accuracy: {train_acc} evaluation accuracy: {acc}" )
def inference_afqmc(args): tokenizer = BertTokenizer.from_pretrained("hfl/chinese-roberta-wwm-ext") model = ClueAFQMCCPT(args.pretrain_dir, args.n_classes, args.is_train).to(args.device) vec = tokenizer(args.text1, args.text2) input_ids = vec["input_ids"] attention_mask = vec["attention_mask"] input_ids = flow.tensor(input_ids, dtype=flow.int32).reshape(1, -1).to(args.device) attention_mask = (flow.tensor(attention_mask, dtype=flow.int32).reshape( 1, -1).to(args.device)) model.load_state_dict(flow.load(args.model_load_dir)) model.eval() output = model(input_ids, attention_mask) output = flow.softmax(output) label = flow.argmax(output) print("Softmax output:", output.numpy()) print("Predict:", label.numpy())
def _eval(model, dev_data, device, batch_size=32): model.eval() model.training = False x_batch, y_batch = batch_loader(dev_data[0], dev_data[1], batch_size, shuffle=False) all_res, all_ground_truths = [], [] total_correct = 0 for data, label in tqdm(zip(x_batch, y_batch), total=len(x_batch)): with flow.no_grad(): data = data.to(device) label = label.to(device) logits = model(data) res = flow.argmax(logits, dim=1) total_correct += (res.numpy() == label.numpy()).sum() all_res.append(res) all_ground_truths.append(label) all_res = flow.cat(all_res) all_ground_truths = flow.cat(all_ground_truths) acc = total_correct / len(all_ground_truths.numpy()) return acc
def test(epoch): global best_acc net.eval() test_loss = 0 correct = 0 total = 0 with flow.no_grad(): for batch_idx, (torch_inputs, torch_targets) in enumerate(testloader): inputs = flow.tensor(torch_inputs.numpy()) targets = flow.tensor(torch_targets.numpy()) inputs, targets = inputs.to(device), targets.to(device) outputs = net(inputs) loss = criterion(outputs, targets) test_loss += loss.item() # _, predicted = outputs.max(1) predicted = flow.argmax(outputs, 1).to(flow.int64) total += targets.size(0) correct += predicted.eq(targets).to(flow.int32).sum().item() progress_bar(batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' % (test_loss/(batch_idx+1), 100.*correct/total, correct, total)) # Save checkpoint. acc = 100.*correct/total if acc > best_acc: print('Saving..') # state = { # 'net': net.state_dict(), # 'acc': acc, # 'epoch': epoch, # } # if not os.path.isdir('checkpoint'): # os.mkdir('checkpoint') # flow.save(state, './checkpoint') best_acc = acc
begin = time.time() time_batch = [] for epoch in range(begin_epochs, N_epochs): MOBILENET_net.train() loss_sum = 0 err_sum = 0 for i in tqdm(range(N_batches)): [inp, lab] = create_batches_rnd(batch_size, data_folder, wav_lst_tr, snt_tr, wlen, lab_dict, 0.2) pout = MOBILENET_net(inp) pred = flow.argmax(pout, dim=1) loss = cost(pout, lab.long()) err = np.mean(pred.numpy() != lab.long().numpy()) loss.backward() optimizer_MOBILENET.step() optimizer_MOBILENET.zero_grad() loss_sum = loss_sum + loss.detach() err_sum = err_sum + err loss_tot = loss_sum / N_batches err_tot = err_sum / N_batches # Full Validation new
def train(opt): # Step 1: init BrainDQN model = DeepQNetwork() model.to("cuda") optimizer = flow.optim.Adam(model.parameters(), lr=opt.lr) criterion = flow.nn.MSELoss() criterion.to("cuda") # Step 2: init Flappy Bird Game game_state = GameState() # Step 3: play game # image.shape = (288,512,3), reward: float, terminal: boolean image, reward, terminal = game_state.frame_step(0) # image.shape = (84, 84) image = pre_processing( image[: game_state.SCREENWIDTH, : int(game_state.BASEY)], opt.image_size, opt.image_size, ) image = flow.Tensor(image, dtype=flow.float32) image = image.to("cuda") state = flow.cat(tuple(image for _ in range(4))).unsqueeze(0) replay_memory = [] iter = 0 # Step 4: run the game while iter < opt.num_iters: model.train() prediction = model(state)[0] # Exploration or exploitation epsilon = opt.final_epsilon + ( (opt.num_iters - iter) * (opt.initial_epsilon - opt.final_epsilon) / opt.num_iters ) u = random() random_action = u <= epsilon if random_action: print("Perform a random action") action = randint(0, 1) else: action = flow.argmax(prediction).numpy()[0] next_image, reward, terminal = game_state.frame_step(action) next_image = pre_processing( next_image[: game_state.SCREENWIDTH, : int(game_state.BASEY)], opt.image_size, opt.image_size, ) next_image = flow.Tensor(next_image) next_image = next_image.to("cuda") next_state = flow.cat((state[0, 1:, :, :], next_image)).unsqueeze(0) replay_memory.append([state, action, reward, next_state, terminal]) if len(replay_memory) > opt.replay_memory_size: del replay_memory[0] batch = sample(replay_memory, min(len(replay_memory), opt.batch_size)) state_batch, action_batch, reward_batch, next_state_batch, terminal_batch = zip( *batch ) state_batch = flow.cat(tuple(state for state in state_batch)) action_batch = flow.Tensor( np.array( [[1, 0] if action == 0 else [0, 1] for action in action_batch], dtype=np.float32, ) ) reward_batch = flow.Tensor(np.array(reward_batch, dtype=np.float32)[:, None]) next_state_batch = flow.cat(tuple(state for state in next_state_batch)) state_batch = state_batch.to("cuda") action_batch = action_batch.to("cuda") reward_batch = reward_batch.to("cuda") next_state_batch = next_state_batch.to("cuda") current_prediction_batch = model(state_batch) next_prediction_batch = model(next_state_batch) y_batch = flow.cat( tuple( reward_batch[i] if terminal_batch[i] else reward_batch[i] + opt.gamma * flow.max(next_prediction_batch[i]) for i in range(reward_batch.shape[0]) ) ) q_value = flow.sum(current_prediction_batch * action_batch, dim=1) loss = criterion(q_value, y_batch) loss.backward() optimizer.step() optimizer.zero_grad() state = next_state iter += 1 print( "Iteration: {}/{}, Action: {}, Loss: {}, Epsilon {}, Reward: {}, Q-value: {}".format( iter + 1, opt.num_iters, action, loss.numpy(), epsilon, reward, flow.max(prediction).numpy()[0], ) ) if (iter + 1) % 100000 == 0: flow.save( model.state_dict(), os.path.join(opt.save_checkpoint_path, "epoch_%d" % (iter + 1)), ) flow.save( model.state_dict(), os.path.join(opt.save_checkpoint_path, "epoch_%d" % (iter + 1)), ) print("train success!")
def infer(): CNN_net.eval() DNN1_net.eval() DNN2_net.eval() loss_sum = 0 err_sum = 0 err_sum_snt = 0 with flow.no_grad(): for i in range(snt_te): [signal, fs] = sf.read(data_folder + wav_lst_te[i]) signal = flow.Tensor(signal).to("cuda") lab_batch = lab_dict[wav_lst_te[i].lower()] # split signals into chunks beg_samp = 0 end_samp = wlen N_fr = int((signal.shape[0] - wlen) / (wshift)) sig_arr = flow.zeros((Batch_dev, wlen), dtype=flow.float32).to("cuda") lab = (flow.zeros(N_fr + 1) + lab_batch).to("cuda").long() pout = flow.zeros((N_fr + 1, class_lay[-1]), dtype=flow.float32).to("cuda") count_fr = 0 count_fr_tot = 0 while end_samp < signal.shape[0]: sig_arr[count_fr, :] = signal[beg_samp:end_samp] beg_samp = beg_samp + wshift end_samp = beg_samp + wlen count_fr = count_fr + 1 count_fr_tot = count_fr_tot + 1 if count_fr == Batch_dev: inp = flow.Tensor(sig_arr).to(sig_arr.device) pout[count_fr_tot - Batch_dev:count_fr_tot, :] = DNN2_net( DNN1_net(CNN_net(inp))) count_fr = 0 sig_arr = flow.zeros((Batch_dev, wlen), dtype=flow.float32).to("cuda") if count_fr > 0: inp = flow.Tensor(sig_arr[0:count_fr]).to(sig_arr.device) pout[count_fr_tot - count_fr:count_fr_tot, :] = DNN2_net( DNN1_net(CNN_net(inp))) pred = flow.argmax(pout, dim=1) loss = cost(pout, lab.long()) err = np.mean(pred.numpy() != lab.long().numpy()) best_class = flow.argmax(flow.sum(pout, dim=0), dim=0) err_sum_snt = err_sum_snt + (best_class.numpy() != lab[0].numpy()) loss_sum = loss_sum + loss.detach() err_sum = err_sum + err err_tot_dev_snt = err_sum_snt / snt_te loss_tot_dev = loss_sum / snt_te err_tot_dev = err_sum / snt_te print("loss_te=%f err_te=%f err_te_snt=%f" % (loss_tot_dev.numpy(), err_tot_dev, err_tot_dev_snt))
def _argmax(self, dim=None, keepdim=None): return flow.argmax(self, dim=dim, keepdim=keepdim)
def test_argmax_index_error(test_case): with test_case.assertRaises(Exception) as context: x = flow.ones((4, 4), dtype=flow.float32, requires_grad=True) y = flow.argmax(x, dim=4) test_case.assertTrue( "Dimension out of range" in str(context.exception))