class Testing: def __init__(self, trainedModel, pathTest, batchSize, imageSize): super(Testing, self).__init__() self.model = ConvNet(10) state_dict = torch.load(trainedModel) self.model.load_state_dict(state_dict) self.pathTest = pathTest self.imageSize = imageSize self.batchSize = batchSize self.data_size = calculate_data_size(self.pathTest) self.data_loader = run_loader('test', self.pathTest, self.batchSize, self.imageSize, shuffle=False) self.test() def test(self): self.model.eval() acc = 0 y_hat = [] y_true = [] for X, y in tqdm(self.data_loader): out = self.model(X) predictions = torch.argmax(out, 1) acc += torch.sum(predictions == y).item() y_hat.append(predictions) y_true.append(y) y_hat = torch.cat(y_hat) y_true = torch.cat(y_true) acc = acc / self.data_size print(acc) print(classification_report(y_hat, y_true))
def main(args): args.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('device: {}'.format(args.device)) # create model model = ConvNet(cfg.NUM_CLASSES).to(args.device) # define loss function (criterion) criterion = nn.CrossEntropyLoss().to(args.device) # load checkpoint if args.model_weight: if os.path.isfile(args.model_weight): print("=> loading checkpoint '{}'".format(args.model_weight)) checkpoint = torch.load(args.model_weight, map_location=args.device) model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(args.model_weight)) else: print("=> no checkpoint found at '{}'".format(args.model_weight)) # Data loading code test_dataset = ImageFolder(cfg.TEST_PATH, mode='test') test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) # Evaluate on test dataset validate(test_loader, model, criterion, args)
def inference_model(network,lstm_out,out_format,model_path): doa_classes = DoaClasses() if out_format == "cartesian": out_dim = 3 elif out_format == "class": out_dim = len(doa_classes.classes) if network == "CNN": model = ConvNet(device, Dropouts(0,0,0), out_dim, doa_classes) elif network == "CRNN": model = CRNN(device, Dropouts(0,0,0), out_dim, doa_classes, lstm_out) model.load_state_dict(torch.load(model_path,map_location=device)) model.eval() model.to(device) return model,doa_classes
def run_inference(model_dir=None, model_path=None, test_data_path=None): hp_file = model_dir + 'hp.pkl' f = open(hp_file, "rb") hp = pickle.load(f) model = ConvNet().to(device) ckpt = torch.load(model_dir + model_path, map_location=device) model.load_state_dict(ckpt['net']) batch_size = 100 dataset = TestDataGenerator(test_data_path) iterator = DataLoader(dataset=dataset, batch_size=batch_size, num_workers=hp['num_workers'], pin_memory=True, shuffle=False, drop_last=True) prediction = np.zeros(10000) with torch.no_grad(): for i, img in enumerate(iterator): print(i) img = img.to(device, dtype=torch.float) logits = model(img) logits = logits.detach().cpu().numpy() pred_label = np.argmax(logits, axis=1) pred_label = pred_label + 1 # class numbers 1 - 10, predicted labels 0 - 9 prediction[i * batch_size:i * batch_size + batch_size] = pred_label test_image_names = os.listdir(test_data_path) for i, name in enumerate(test_image_names): test_image_names[i] = test_image_names[i][0:5] with open(model_dir + 'predictions.csv', 'w') as f: writer = csv.writer(f, delimiter=',') writer.writerow(['Id', 'Category']) for i in range(len(test_image_names)): writer.writerow([test_image_names[i], int(prediction[i])])
def main(): # Device configuration device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print("Using device: ", device) model = ConvNet().to(device) try: model.load_state_dict(torch.load(FILE)) print("Finished loading model.") model.eval() except IOError: print("Failed to load model. Model might not exist.") return print("Print Network Parameters:") for param in model.parameters(): print(param) print("Print model state dict: ", model.state_dict()) with torch.no_grad(): print("Perform inference/testing here...")
with open('char_dict', 'rb') as f: class_dict = pickle.load(f) num_classes = len(class_dict) # 读取数据 transform = transforms.Compose([ transforms.Resize((64, 64)), transforms.ToTensor(), ]) dataset = HWDB(path=data_path, transform=transform) print("训练集数据:", dataset.train_size) print("测试集数据:", dataset.test_size) trainloader, testloader = dataset.get_loader(batch_size) net = ConvNet(num_classes) if torch.cuda.is_available(): net = net.cuda() net.load_state_dict(torch.load('checkpoints/handwriting_iter_009.pth')) print('网络结构:\n') #summary(net, input_size=(3, 64, 64), device='cuda') criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=lr) writer = SummaryWriter(log_path) for epoch in range(10, epochs): train(epoch, net, criterion, optimizer, trainloader, writer=writer) valid(epoch, net, testloader, writer=writer) print("epoch%d 结束, 正在保存模型..." % epoch) torch.save(net.state_dict(), save_path + 'handwriting_iter_%03d.pth' % epoch)
os.makedirs(args.output_dir) if not os.path.isdir(os.path.join(args.output_dir, args.img_folder)): os.makedirs(os.path.join(args.output_dir, args.img_folder)) out_name = os.path.join(args.output_dir, args.img_folder) #--------------------------------# face_dataset = ImageData(root_dir=args.input_dir,\ transform=transforms.Compose([PreprocessData(args.scale_size, args.crop_size, mode= args.mode)])) dataloader = DataLoader(face_dataset, batch_size=args.batch_size, shuffle=True) #--------------- Load Weights ----------------# net = ConvNet(3, args.K).to(device) checkpoint = torch.load(os.path.join(args.output_dir, args.checkpoint)) net.load_state_dict(checkpoint['model_state_dict']) #---------------------------------------------# #-------------visualize----------------------# net.eval() with torch.no_grad(): clr = landmark_colors(args.K) for i_batch, sample_batched in enumerate(dataloader): i_image = sample_batched['image'] i_name = sample_batched['name'][0].split("/")[-1] print(i_name) i_image = i_image.float().to(device) out = net(i_image)
std=[0.229, 0.224, 0.225]) ]) return trans(img) # input img = load_image(args.image) img = img.unsqueeze(0).to(device) # create model model = ConvNet(cfg.NUM_CLASSES).to(device) # load checkpoint if args.model_weight: if os.path.isfile(args.model_weight): print("=> loading checkpoint '{}'".format(args.model_weight)) checkpoint = torch.load(args.model_weight, map_location=device) model.load_state_dict(checkpoint['state_dict']) else: print("=> no checkpoint found at '{}'".format(args.model_weight)) # predict model.eval() with torch.no_grad(): scores = model(img) probability = torch.nn.functional.softmax(scores, dim=1) max_value, index = torch.max(probability, 1) print('pred_label:{}, pred_class:{}, conf:{:.6f}'.format( index.item(), idx_to_class[index.item()], max_value.item()))
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=True) model = ConvNet(n_in=7, n_features=64, height=128, width=256, droprate=0).float() model.to(device) print("ConvNet initialized") # model = ResNet(n_in=7, n_features=16, height=128, width=256, droprate=0, num_blocks=2).float() # model.to(device) # print("ResNet initialized") model.load_state_dict( torch.load("../Models/ConvNet_final", map_location=device)) model.eval() print("Model loaded") classes = test_loader.dataset.get_image_classes() test_correct = 0 class_correct = list(0. for i in range(len(classes))) class_total = list(0. for i in range(len(classes))) class_pred = list(0. for i in range(len(classes))) pred_ = [] target_ = [] for data, target, scaler in test_loader: data, scaler = data.to(device), scaler.to(device) with torch.no_grad(): output = model(data)
images=test_data) eval_dataset = MillionBlocksDataset(labels_arr=eval_labels_arr, images=eval_data) train_loader = DataLoader(train_dataset, batch_size=test_batch_size, shuffle=False) test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False) eval_loader = DataLoader(eval_dataset, batch_size=test_batch_size, shuffle=False) # ConvNet model model = ConvNet(num_classes).to(device) model.load_state_dict(torch.load('./saved_models/model_arr_final.ckpt')) # Test the model # eval mode (batchnorm uses moving mean/var instead of mini-batch mean/var) class_to_arr_vec_dict = { 0: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 1: [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 2: [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
from model import SimpleNet, ResNet, ConvNet from mcts import mcts from agents import netAgent, processObservation from epoch_training import selfplay, net_update from evaluation import evaluate model = ConvNet(42, 7, 64) defaultModel = ConvNet(42, 7, 64) log = open("log.txt", 'w') # defaultModel.load_state_dict(torch.load('parameters_simple128.pth')) optimizer = torch.optim.SGD(model.parameters(), lr=0.01) for epoch in range(1000): agent = netAgent(model, return_probs=True) against = netAgent(defaultModel, incorrect_moves=False) training_data = selfplay(agent, against, num=10) net_update(model, training_data, optimizer) agent = netAgent(model, incorrect_moves=False, best_move=False) against = netAgent(defaultModel, incorrect_moves=False, best_move=False) result = evaluate(agent, against, 1000) log.write("Epoch " + str(epoch) + " Result: " + str(result) + "\n") print("Test result: ", result) if (result > 0.65): torch.save(model.state_dict(), "parameters_simple128.pth") defaultModel.load_state_dict(model.state_dict()) print("switch") log.write("Switch\n")
def main(args): best_acc1 = 0 os.makedirs('checkpoints', exist_ok=True) args.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('device: {}'.format(args.device)) # create model model = ConvNet(cfg.NUM_CLASSES).to(args.device) #model.apply(weights_init_normal) # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().to(args.device) optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume, map_location=args.device) args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code train_dataset = ImageFolder(cfg.TRAIN_PATH) val_dataset = ImageFolder(cfg.VAL_PATH) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) logger = Logger('./logs') for epoch in range(args.start_epoch, args.epochs): # train for one epoch adjust_learning_rate(optimizer, epoch, args) train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on validation set val_loss, val_acc = validate(val_loader, model, criterion, args) # remember best acc@1 and save checkpoint is_best = val_acc > best_acc1 best_acc1 = max(val_acc, best_acc1) # log info = { 'train_loss': float(train_loss), 'train_acc': float(train_acc), 'val_loss': float(val_loss), 'val_acc': float(val_acc) } for tag, value in info.items(): logger.scalar_summary(tag, value, epoch) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer': optimizer.state_dict(), }, is_best)
import torchvision.transforms as transforms from model import ConvNet, Fully from data import TestDataset if __name__ == "__main__": data_path, model_type, output = sys.argv[1], sys.argv[2], sys.argv[3] if model_type == 'conv': model = ConvNet() elif model_type == 'fully': model = Fully() ####################################################################### # Modifiy this part to load your trained model # TODO model.load_state_dict(torch.load('./checkpoint/%s.pth' % model.name())) ####################################################################### use_cuda = torch.cuda.is_available() if use_cuda: model.cuda() model.eval() # Load data trans = transforms.Compose([ transforms.Grayscale(), transforms.ToTensor(), transforms.Normalize((0.5, ), (1.0, )) ]) test_set = TestDataset(data_path, transform=trans) print('Length of Testing Set:', len(test_set))
class Learner: def __init__(self, args, q_batch): self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') self.q_batch = q_batch self.learn_step_counter = 0 self.gamma = args.gamma self.batch_size = args.batch_size self.env = gym.make(args.env) self.n_act = self.env.action_space.n self.n_state = self.env.observation_space.shape[0] self.n_atom = args.atom self.v_min = args.v_min self.v_max = args.v_max self.dz = (self.v_max - self.v_min) / (self.n_atom - 1) self.z = [self.v_min + i * self.dz for i in range(self.n_atom)] self.z_space = torch.FloatTensor(self.z).to(self.device) self.net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device) self.target_net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device) self.optimizer = optim.Adam(self.net.parameters(), lr=args.lr) def learn(self): while True: self.learn_step_counter += 1 # target parameter update if self.learn_step_counter % 10 == 0: self.update_target() states, actions, rewards, next_states, dones = self.q_batch.get(block=True) states = torch.FloatTensor(states).to(self.device) actions = torch.LongTensor(actions).to(self.device) next_states = torch.FloatTensor(next_states).to(self.device) dones = [int(i) for i in dones] # action value distribution prediction # (m, N_ACTIONS, N_ATOM) curr_q = self.net(states) # 実際に行動したQだけを取り出す curr_q = torch.stack([curr_q[i].index_select(0, actions[i]) for i in range(self.batch_size)]).squeeze(1) # get next state value next_q = self.net(next_states).detach() # (m, N_ACTIONS, N_ATOM) next_q = torch.sum(next_q * self.z_space.view(1, 1, -1), dim=2) # (m, N_ACTIONS) next_action = next_q.argmax(dim=1) # (m) # target_q target_q = self.target_net(next_states).detach().cpu().numpy() target_q = [target_q[i, action, :] for i, action in enumerate(next_action)] target_q = np.array(target_q) # (m, N_ATOM) m_prob = np.zeros((self.batch_size, self.n_atom)) # (m, N_ATOM) # we didn't vectorize the computation of target assignment. for i in range(self.batch_size): for j in range(self.n_atom): Tz = np.fmin(self.v_max, np.fmax(self.v_min, rewards[i] + (1 - dones[i]) * 0.99 * (self.v_min + j * self.dz) ) ) bj = (Tz - self.v_min) / self.dz lj = np.floor(bj).astype(int) # m_l uj = np.ceil(bj).astype(int) # m_u # calc prob mass of relative position weighted with distance m_prob[i, lj] += (dones[i] + (1 - dones[i]) * target_q[i][j]) * (uj - bj) m_prob[i, uj] += (dones[i] + (1 - dones[i]) * target_q[i][j]) * (bj - lj) m_prob = m_prob / m_prob.sum(axis=1, keepdims=1) m_prob = torch.FloatTensor(m_prob).to(self.device) # print(curr_q) # calc huber loss, dont reduce for importance weight loss = - torch.mean(torch.sum(m_prob * torch.log(curr_q + 1e-20), dim=1)) # (m , N_ATOM) if self.learn_step_counter % 100 == 0: print('loss:', loss.item()) # backprop loss self.optimizer.zero_grad() loss.backward() self.optimizer.step() def update_target(self): self.target_net.load_state_dict(self.net.state_dict())
class Actor: def __init__(self, args, actor_id, q_trace, learner): self.seed = args.seed self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') self.q_trace = q_trace self.learner = learner self.env = gym.make(args.env) self.env_state = self.env.reset() self.n_act = self.env.action_space.n self.n_state = self.env.observation_space.shape[0] self.n_atom = args.atom self.net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device) # パラメータ self.v_min = args.v_min self.v_max = args.v_max self.dz = float(self.v_max - self.v_min) / (self.n_atom - 1) self.z = [self.v_min + i * self.dz for i in range(self.n_atom)] # self.z = np.linspace(self.v_min, self.v_max, self.n_atom) self.value_range = torch.FloatTensor(self.z).to(self.device) # (N_ATOM) self.step_num = args.step_num self.eps_greedy = 0.4 ** (1 + actor_id * 7 / (args.n_actors - 1)) \ if args.n_actors > 1 else 0.4 self.n_episodes = 0 self.n_steps = 0 def performing(self): # torch.manual_seed(self.seed) while True: self.load_model() self.train_episode() if self.n_episodes % 10 == 0: rewards = self.evaluation(self.env) rewards_mu = np.array([np.sum(np.array(l_i), 0) for l_i in rewards]).mean() print("Episode %d, Average Reward %.2f" % (self.n_episodes, rewards_mu)) def train_episode(self): done = False state = self.env.reset() self.env_state = state while not done: self.n_steps += 1 action = self.choose_action(self.env_state) next_state, reward, done, _ = self.env.step(action) reward = 0 if done: if self.n_steps > 195: reward = 1 else: reward = -1 # push memory self.q_trace.put((state, action, reward, next_state, done), block=True) self.env_state = next_state if done: self.env_state = self.env.reset() break if done: self.n_steps = 0 self.n_episodes += 1 self.episode_done = True else: self.episode_done = False def choose_action(self, state): if np.random.uniform() >= self.eps_greedy: state = torch.FloatTensor(state).to(self.device).unsqueeze(0) action_value_dist = self.net(state) action_value = torch.sum(action_value_dist * self.value_range.view(1, 1, -1), dim=2) action = torch.argmax(action_value, dim=1).data.cpu().numpy().item() else: action = np.random.randint(0, self.n_act) return action def evaluation(self, env_eval): rewards = [] for i in range(10): rewards_i = [] state = env_eval.reset() action = self.action(state) state, reward, done, _ = env_eval.step(action) rewards_i.append(reward) while not done: action = self.action(state) state, reward, done, _ = env_eval.step(action) rewards_i.append(reward) rewards.append(rewards_i) return rewards def action(self, state): state = torch.FloatTensor([state]).to(self.device) action_value_dist = self.net(state) action_value = torch.sum(action_value_dist * self.value_range.view(1, 1, -1), dim=2) action = torch.argmax(action_value, dim=1).data.cpu().numpy().item() return action def load_model(self): try: self.net.load_state_dict(self.learner.net.state_dict()) except: print('load error')
class Learner: def __init__(self, args, q_batch): self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.q_batch = q_batch self.update_count = 0 self.gamma = args.gamma self.batch_size = args.batch_size self.env_eval = gym.make(args.env) self.n_act = self.env_eval.action_space.n self.n_state = self.env_eval.observation_space.shape[0] self.n_quant = args.quant self.target_net_update_freq = args.target_net_update_freq self.net = ConvNet(self.n_state, self.n_act, self.n_quant).to(self.device) self.target_net = ConvNet(self.n_state, self.n_act, self.n_quant).to(self.device) self.optimizer = optim.Adam(self.net.parameters(), lr=args.lr) def learn(self): while True: self.update_count += 1 if self.update_count % 10 == 0: rewards = self.evaluation() rewards_mu = np.array( [np.sum(np.array(l_i), 0) for l_i in rewards]).mean() print('update cnt %d Eval Reward %.2f' % (self.update_count, rewards_mu)) # target parameter update if self.update_count % self.target_net_update_freq == 0: self.update_target() states, actions, rewards, next_states, dones = self.q_batch.get( block=True) states = torch.FloatTensor(states).to(self.device) actions = torch.LongTensor(actions).to(self.device) next_states = torch.FloatTensor(next_states).to(self.device) dones = np.array([int(i) for i in dones]) # action value distribution prediction # [BATCH, N_QUANT, N_ACTIONS] curr_q, tau = self.net(states) # 実際に行動したQだけを取り出す # [BATCH, N_QUANT, 1] curr_q = torch.stack([ curr_q[i].index_select(1, actions[i]) for i in range(self.batch_size) ]) # # [BATCH, N_QUANT, N_QUANT] curr_q = curr_q.repeat(1, 1, self.n_quant) # get next state value # [BATCH, N_QUANT, N_ACTIONS] next_q, _ = self.net(next_states) next_action = next_q.sum(dim=1).argmax(dim=1) # target_q with torch.no_grad(): # [BATCH, N_QUANT, N_ACT] target_q, _ = self.target_net(next_states) target_q = target_q.detach().cpu().numpy() # [BATCH, N_QUANT, 1] target_q = np.array([ target_q[i, :, action] for i, action in enumerate(next_action) ]) target_q = rewards.reshape( -1, 1) + self.gamma * target_q * (1 - dones.reshape(-1, 1)) target_q = torch.FloatTensor(target_q).to( self.device).unsqueeze(2) # # [BATCH, N_QUANT, N_QUANT] target_q = target_q.repeat(1, 1, self.n_quant) target_q = target_q.permute(0, 2, 1) # loss = F.smooth_l1_loss(curr_q, target_q.detach(), reduction='none') # (BATCH, N_QUANT, N_QUANT) tau = tau.repeat(1, 1, self.n_quant) diff = target_q - curr_q loss = self.huber(diff) I_delta = (diff < 0).double() loss *= torch.abs(tau - I_delta) # huber loss loss = torch.mean(torch.sum(torch.mean(loss, dim=2), dim=1)) # backprop loss self.optimizer.zero_grad() loss.backward() self.optimizer.step() def huber(self, x): cond = (x.abs() < 1.0).float().detach() return 0.5 * x.pow(2) * cond + (x.abs() - 0.5) * (1.0 - cond) def update_target(self): self.target_net.load_state_dict(self.net.state_dict()) def evaluation(self): rewards = [] for _ in range(10): rewards_i = [] state = self.env_eval.reset() action = self.action(state) state, reward, done, _ = self.env_eval.step(action) rewards_i.append(reward) while not done: action = self.action(state) state, reward, done, _ = self.env_eval.step(action) rewards_i.append(reward) rewards.append(rewards_i) return rewards def action(self, state): state = torch.FloatTensor(state).to(self.device).unsqueeze(0) action_value, _ = self.net(state) # if self.update_count > 3000: # dist_action = action_value[0].detach().cpu().numpy() # sns.distplot(dist_action[:, 0], bins=10, color='red') # sns.distplot(dist_action[:, 1], bins=10, color='blue') # plt.show() action_value = action_value[0].sum(dim=0) action = torch.argmax(action_value).detach().cpu().item() return action
class Actor: def __init__(self, args, actor_id, q_trace, learner): self.actor_id = actor_id self.seed = args.seed self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') self.q_trace = q_trace self.learner = learner self.env = gym.make(args.env) self.env_state = self.env.reset() self.n_act = self.env.action_space.n self.n_state = self.env.observation_space.shape[0] self.n_quant = args.quant self.net = ConvNet(self.n_state, self.n_act, self.n_quant).to(self.device) self.eps_greedy = 0.4 ** (1 + actor_id * 7 / (args.n_actors - 1)) \ if args.n_actors > 1 else 0.4 self.n_episodes = 0 self.n_steps = 0 def performing(self): torch.manual_seed(self.seed) while True: self.load_model() self.train_episode() def train_episode(self): self.n_episodes += 1 done = False self.env_state = self.env.reset() while not done: self.n_steps += 1 action = self.choose_action(self.env_state) next_state, reward, done, _ = self.env.step(action) # reward = 0 # if done: # reward = -1 # if self.n_steps > 190: # reward = 1 # push memory self.q_trace.put((self.env_state, action, reward, next_state, done), block=True) self.env_state = next_state if done: print(' '*30, 'Actor:', self.actor_id, 'Episode:', self.n_episodes, ' steps:', self.n_steps) self.n_steps = 0 def choose_action(self, state): if np.random.uniform() >= self.eps_greedy: state = torch.FloatTensor(state).to(self.device).unsqueeze(0) action_value, _ = self.net(state) action_value = action_value[0].sum(dim=0) action = torch.argmax(action_value).detach().cpu().item() else: action = np.random.randint(0, self.n_act) return action def load_model(self): try: self.net.load_state_dict(self.learner.net.state_dict()) except: print('load error')
def train(pre_trained=None): # create folder to save models and loss graphs reference = hp['net_type'] + str(time.strftime("_%Y%m%d_%H%M%S")) checkpoints_folder = hp["output_dir"] + '/checkpoints/' + reference os.makedirs(checkpoints_folder, exist_ok=True) # save hyper parameter settings pickle_file_location = checkpoints_folder + "/hp.pkl" pickle_file = open(pickle_file_location, "wb") pickle.dump(hp, pickle_file) pickle_file.close() # create data iterator train_data_set = DataGenerator(hp) iterator = DataLoader(dataset=train_data_set, batch_size=hp['batch_size'], num_workers=hp['num_workers'], pin_memory=True, shuffle=False, drop_last=True) val_set = ValidationDataGenerator(hp) val_set_iterator = DataLoader(dataset=val_set, batch_size=50, num_workers=hp['num_workers'], pin_memory=True, shuffle=False, drop_last=True) # create model and loss model = ConvNet().to(device) loss = CrossEntropyLoss().to(device) # optimizer optimizer = torch.optim.Adam(params=model.parameters(), lr=hp['learning_rate']) start_epoch = 0 # load pre trained model if pre_trained is not None: ckpt = torch.load(pre_trained) model.load_state_dict(ckpt['net']) optimizer.load_state_dict(ckpt['opt']) start_epoch = ckpt['epoch'] + 1 # init loss arrays classification_loss = np.zeros(hp['num_epochs']) train_accuracy = np.zeros(hp['num_epochs']) val_accuracy = np.zeros(hp['num_epochs']) # training loop for epoch in range(start_epoch, hp['num_epochs']): c_loss = 0 acc = 0 for i, (img, label) in enumerate(iterator): img = img.to(device, dtype=torch.float) label = label.to(device, dtype=torch.float) optimizer.zero_grad() logits = model(img) l = loss(logits, label.long()) l.backward() optimizer.step() c_loss += l.item() # calc accuracy logits = logits.detach().cpu().numpy() label = label.detach().cpu().numpy() acc += utils.classification_accuracy(logits, label) print("epoch = {}, Training_sample={}, classification loss ={}". format(epoch, i, l.item())) # average loss per epoch classification_loss[epoch] = c_loss / (i + 1) # average accuracy per epoch train_accuracy[epoch] = acc / (i + 1) print("epoch = {}, average classification loss ={}".format( epoch, classification_loss[epoch])) print("epoch = {}, Training accuracy ={}".format( epoch, train_accuracy[epoch])) with torch.no_grad(): val_acc = 0 for i, (img, label) in enumerate(val_set_iterator): img = img.to(device, dtype=torch.float) label = label.to(device, dtype=torch.float) logits = model(img) # calc accuracy logits = logits.detach().cpu().numpy() label = label.detach().cpu().numpy() val_acc += utils.classification_accuracy(logits, label) val_accuracy[epoch] = val_acc / (i + 1) print("epoch = {}, Validation set accuracy ={}".format( epoch, val_accuracy[epoch])) # plot accuracy curves and save model plt.plot(range(1, len(train_accuracy) + 1), train_accuracy, 'b-', label=" Train Accuracy") plt.plot(range(1, len(val_accuracy) + 1), val_accuracy, 'r-', label="Validation Accuracy") plt.xlabel("epochs") plt.ylabel("accuracy") plt.legend(loc='best') plt.savefig(checkpoints_folder + "/accuracy.jpeg", bbox_inches="tight") plt.clf() net_save = { 'net': model.state_dict(), 'opt': optimizer.state_dict(), 'epoch': epoch } torch.save( net_save, checkpoints_folder + "/convnet_ethiopian_mnist_epoch{}.pth".format(epoch))
# coding:utf-8 import numpy as np import torch import torchvision.transforms as transforms from model import ConvNet from PIL import Image model_path = "./model.ckpt" img_path = "./12.png" model = ConvNet() print "load pretrained model from %s" % model_path model.load_state_dict(torch.load(model_path)) transformer = transforms.ToTensor() image = Image.open(img_path).convert('L') #image.resize((28, 28), Image.BILINEAR) image = transformer(image) image = image.view(1, *image.size()) model.eval() output = model(image) preds = torch.max(output, 1)[1] print preds.item()
import cv2 import torch from torchsummary import summary from torchvision.transforms import ToTensor import numpy as np from tensorboardX import SummaryWriter from model import ConvNet from widerface import WIDERFaceDetection from augmentations import SSDAugmentation if __name__ == "__main__": net = ConvNet() net.load_state_dict(torch.load('no_gassuion_epoch240.pth')) net = net.eval() if torch.cuda.is_available(): net = net.cuda() summary(net.cuda(), input_size=(3, 640, 640), batch_size=1, device='cuda') WIDERFace_ROOT = r"F:\Datasets\人脸识别\WIDERFACE" dataset = WIDERFaceDetection(WIDERFace_ROOT) writer = SummaryWriter('eval_log') # img = dataset.pull_image(1144) img = cv2.imread('2.jpg') # cv2.waitKey() # _, img = cv2.VideoCapture(0).read() # img = cv2.resize(img, (640, 640)) src = img.copy() img = ToTensor()(img).unsqueeze(0)
import torch import numpy as np from sklearn import metrics import matplotlib.pyplot as plt from data import TwoClassCifar10 from model import ConvNet, LogisticRegression from config import Config as config test_dataset = TwoClassCifar10(config.root, train=False) conv_net = ConvNet(config.input_channel, 2) lr_model = LogisticRegression(config.cifar10_input_size) conv_net.load_state_dict(torch.load("model/2020428163925_0.719000.pth")) lr_model.load_state_dict(torch.load("model/2020428163951_0.589000.pth")) conv_preds = [] lr_preds = [] targets = [] with torch.no_grad(): for image, label in test_dataset: image.unsqueeze_(0) conv_pred = conv_net(image) lr_pred = lr_model(image) conv_pred = torch.max(torch.softmax(conv_pred, dim=1), dim=1)[0].squeeze() lr_pred = torch.sigmoid(lr_pred).squeeze() conv_preds.append(conv_pred.item()) lr_preds.append(lr_pred.item()) targets.append(label) fpr, tpr, thresholds = metrics.roc_curve(targets, conv_preds)
from model import ConvNet # Load in serialized model, config, and scaler with open("config.json", "r") as f: CONFIG = json.load(f) time_steps = CONFIG["timesteps"] with open("scaler.pck", "rb") as f: scaler = pickle.load(f) ensemble = [] for s in [2, 3, 5, 7, 11, 13, 17]: for pwr in [1.5, 2.4, 2.5]: model = ConvNet(CONFIG['n_feat'], CONFIG['n_filters'], 2, CONFIG['dropout']) model.load_state_dict(torch.load('conv_{:d}_{:.1f}'.format(s, pwr))) model.eval() ensemble.append(model) # THIS MUST BE DEFINED FOR YOUR SUBMISSION TO RUN def predict_dst( solar_wind_7d: pd.DataFrame, satellite_positions_7d: pd.DataFrame, latest_sunspot_number: float, ) -> Tuple[float, float]: """ Take all of the data up until time t-1, and then make predictions for times t and t+1. Parameters ---------- solar_wind_7d: pd.DataFrame
def pred_prob(arg_path, field_path, pth_path, doc, device=torch.device('cpu')): # Load args # with open(arg_path) as f: # args = json.load(f)['args'] arg_path = os.path.join( 'https://raw.githubusercontent.com/qianyingw/rob-pome/master/rob-app', arg_path) with urllib.request.urlopen(arg_path) as url: args = json.loads(url.read().decode())['args'] # Load TEXT field field_url = os.path.join( 'https://github.com/qianyingw/rob-pome/raw/master/rob-app', field_path) field_path = wget.download(field_url) with open(field_path, "rb") as fin: TEXT = dill.load(fin) os.remove(field_path) unk_idx = TEXT.vocab.stoi[TEXT.unk_token] # 0 pad_idx = TEXT.vocab.stoi[TEXT.pad_token] # 1 # Load model if args['net_type'] == 'cnn': sizes = args['filter_sizes'].split(',') sizes = [int(s) for s in sizes] model = ConvNet(vocab_size=args['max_vocab_size'] + 2, embedding_dim=args['embed_dim'], n_filters=args['num_filters'], filter_sizes=sizes, output_dim=2, dropout=args['dropout'], pad_idx=pad_idx, embed_trainable=args['embed_trainable'], batch_norm=args['batch_norm']) if args['net_type'] == 'attn': model = AttnNet(vocab_size=args['max_vocab_size'] + 2, embedding_dim=args['embed_dim'], rnn_hidden_dim=args['rnn_hidden_dim'], rnn_num_layers=args['rnn_num_layers'], output_dim=2, bidirection=args['bidirection'], rnn_cell_type=args['rnn_cell_type'], dropout=args['dropout'], pad_idx=pad_idx, embed_trainable=args['embed_trainable'], batch_norm=args['batch_norm'], output_attn=False) # Load checkpoint pth_url = os.path.join( 'https://github.com/qianyingw/rob-pome/raw/master/rob-app', pth_path) pth_path = wget.download(pth_url) checkpoint = torch.load(pth_path, map_location=device) os.remove(pth_path) state_dict = checkpoint['state_dict'] model.load_state_dict(state_dict, strict=False) model.cpu() # Load pre-trained embedding pretrained_embeddings = TEXT.vocab.vectors model.embedding.weight.data.copy_(pretrained_embeddings) model.embedding.weight.data[unk_idx] = torch.zeros( args['embed_dim']) # Zero the initial weights for <unk> tokens model.embedding.weight.data[pad_idx] = torch.zeros( args['embed_dim']) # Zero the initial weights for <pad> tokens # Tokenization tokens = [tok.text.lower() for tok in nlp.tokenizer(doc)] idx = [TEXT.vocab.stoi[t] for t in tokens] while len(idx) < args['max_token_len']: idx = idx + [1] * args['max_token_len'] if len(idx) > args['max_token_len']: idx = idx[:args['max_token_len']] # Prediction model.eval() doc_tensor = torch.LongTensor(idx).to(device) doc_tensor = doc_tensor.unsqueeze( 1) # bec AttnNet input shape is [seq_len, batch_size] probs = model(doc_tensor) probs = probs.data.cpu().numpy()[0] # print("Prob of RoB reported: {:.4f}".format(probs[1])) return probs[1]
class Wrapper(object): """docstring for Wrapper.""" def __init__(self, config, cont=None): super(Wrapper, self).__init__() with open(config, 'r') as f: config = json.load(f) self.config = config self.best_path = str(self.config['model']['model_save_path'] + self.config['name'] + '_model_best.pt') self.model = ConvNet(config['model']) self.continuing = False if cont is not None: print('loading in weights') self.load_model(cont) self.continuing = True self.cuda = torch.cuda.is_available() if self.cuda: print('using cuda') self.model.cuda() def train(self): model = self.model config = self.config trainloader = DataLoader( KanjiDataset(self.config, train=True), batch_size=config['train']['batch_size'], shuffle=True, pin_memory=True) # self.valloader = DataLoader( # KanjiDataset(self.config, train=False), # batch_size=config['train']['batch_size'], pin_memory=True) self.valset = KanjiDataset(self.config, train=False) objective = nn.CrossEntropyLoss() self.objective = objective optimizer = optim.Adam(model.parameters(), lr=config['train']['learning_rate']) # bestloss = float('Inf') if not self.continuing else self.valid() bestacc = 0.0 if not self.continuing else self.eval()[0] past_best = 0 max_past = 50 for e in range(config['train']['epochs']): avgloss = 0.0 for i, (x, y) in enumerate(trainloader): if self.cuda: x = x.cuda(async=True) y = y.cuda(async=True) optimizer.zero_grad() preds = model(x) loss = objective(preds, y) avgloss += loss.item() loss.backward() optimizer.step() preds = None gc.collect() avgloss /= len(trainloader) # vloss = self.valid() vacc = self.eval()[0] if e%5==0: print('epoch: {}, loss: {:.4f}, val_acc: {:.4f}' .format( e+1, avgloss, vacc ) ) # print('epoch: {}, loss: {:.4f}, val_loss: {:.4f}, memory: {:.4f}' # .format(e+1, avgloss, vloss, torch.cuda.memory_allocated(0) / 1e9 ) ) # if e%20==0: # self.print_acc() # if vloss < bestloss: if vacc > bestacc: path = str(self.config['model']['model_save_path'] + self.config['name'] + '_model_{:.4f}.pt'.format(vacc)) self.save_model(path) self.save_model(self.best_path) # bestloss = vloss bestacc = vacc past_best = 0 else: past_best += 1 if past_best >= max_past: print('past') break self.valloader = None self.print_acc() return def valid(self): loss = 0.0 for (x, y) in self.valloader: if self.cuda: x = x.cuda(async=True) y = y.cuda(async=True) loss += self.objective(self.model(x), y).item() return loss/len(self.valloader) def eval(self, train=False): validset = self.valset if train else KanjiDataset(self.config, train=False) acc = 0 conf = np.zeros((self.config['model']['classes'], self.config['model']['classes']), dtype=np.int32) for (x, y) in validset: pred = self.predict(x) acc += (pred == y) conf[y, pred] = conf[y, pred] + 1 return acc/len(validset), conf def print_acc(self): acc, conf = self.eval() print('acc:', acc) print('conf:\n', conf) def predict(self, image): image = torch.unsqueeze(image, 0) if self.cuda: image = image.cuda(async=True) pred = self.model(image) pred = torch.argmax(pred[0]) return pred.item() def save_model(self, path): torch.save( self.model.state_dict(), path ) print('save:', path) def load_model(self, cont): path = self.best_path if cont != 'cont': path = join(self.config['model']['model_save_path'], cont) print('loading path:', path) self.model.load_state_dict( torch.load( path ) )