def main(): # parse arguments args = parse_args() if args is None: exit() # open session with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: cnn = ResNet(sess, args) # build graph cnn.build_model() # show network architecture show_all_variables() if args.phase == 'train' : # launch the graph in a session cnn.train() print(" [*] Training finished! \n") cnn.test() print(" [*] Test finished!") if args.phase == 'test' : cnn.test() print(" [*] Test finished!")
class predict(): def __init__(self, weights_path, conf_thres=0.7, nms_thres=0.5): self.conf_thres = conf_thres self.nms_thres = nms_thres model_dict = torch.load(weights_path) anchors = model_dict['anchors'].to('cuda') self.model = ResNet(anchors, Istrain=False).to('cuda') self.model.load_state_dict(model_dict['net']) self.model.eval() def __call__(self, inputs): inputs = torch.from_numpy(inputs) inputs = Variable(inputs, requires_grad=False).to('cuda') with torch.no_grad(): _, outputs = self.model(inputs) outputs = non_max_suppression(outputs, conf_thres=self.conf_thres, nms_thres=self.nms_thres) outputs_numpy = [] for output in outputs: if output is None: outputs_numpy.append(None) else: outputs_numpy.append(output.detach().cpu().numpy()) return outputs_numpy
def build_model(self): """ Instantiates the model, loss criterion, and optimizer """ # instantiate model self.model = ResNet(self.config, self.input_channels, self.class_count) # instantiate loss criterion self.criterion = nn.CrossEntropyLoss() # instantiate optimizer self.optimizer = optim.SGD(self.model.parameters(), lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) self.scheduler = scheduler.StepLR(self.optimizer, step_size=self.sched_step_size, gamma=self.sched_gamma) # print network self.print_network(self.model, 'ResNet') # use gpu if enabled if torch.cuda.is_available() and self.use_gpu: self.model.cuda() self.criterion.cuda()
def main(args): # create model if "resnet" in args.backbone or "resnext" in args.backbone: print('resnet', args.att) model = ResNet(args) elif 'b' in args.backbone: model = EfficientNet.from_pretrained(f'efficientnet-{args.backbone}', 8) if args.input_level == 'per-study': # add decoder if train per-study if args.conv_lstm: decoder = ConvDecoder(args) else: decoder = Decoder(args) encoder = model model = (encoder, decoder) if args.input_level == 'per-study': model[0].cuda(), model[1].cuda() else: model = model.cuda() # 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, "cpu") input_level = checkpoint['input_level'] assert input_level == args.input_level if args.input_level == 'per-study': encoder, decoder = model load_state_dict(checkpoint.pop('encoder'), encoder) load_state_dict(checkpoint.pop('decoder'), decoder) else: load_state_dict(checkpoint.pop('state_dict'), model) # load_state_dict(checkpoint.pop('state_dict'), model) epoch = checkpoint['epoch'] best_loss = checkpoint['best_loss'] print( f"=> loaded checkpoint '{args.resume}' (loss {best_loss:.4f}@{epoch})" ) else: raise ValueError("=> no checkpoint found at '{}'".format( args.resume)) # if args.to_stack: # loader = get_test_dl(args) # to_submit(args, model, loader) # else: if args.val: val_dl = get_val_dl(args) to_stacking_on_val(args, model, val_dl) else: test_dl = get_test_dl(args) to_stacking_on_test(args, model, test_dl)
def main(args): # Image preprocessing transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.033, 0.032, 0.033), (0.027, 0.027, 0.027))]) # Load vocabulary wrapper with open(args.vocab_path, 'rb') as f: vocab = pickle.load(f) len_vocab = vocab.idx # Build Models encoder = ResNet(ResidualBlock, [3, 3, 3], len_vocab) encoder.eval() # evaluation mode (BN uses moving mean/variance) decoder = DecoderRNN(len_vocab, args.hidden_size, len(vocab), args.num_layers) attn_encoder = AttnEncoder(ResidualBlock, [3, 3, 3]) attn_encoder.eval() attn_decoder = SANDecoder(args.feature_size, args.hidden_size, len(vocab), args.num_layers) # Load the trained model parameters attn_encoder.load_state_dict(torch.load(args.encoder_path)) attn_decoder.load_state_dict(torch.load(args.decoder_path)) # Prepare Image image = load_image(args.image, transform) image_tensor = to_var(image, volatile=True) # If use gpu if torch.cuda.is_available(): attn_encoder.cuda(1) attn_decoder.cuda(1) # Generate caption from image feature = attn_encoder(image_tensor) sampled_ids = attn_decoder.sample(feature) ids_arr = [] for element in sampled_ids: temp = element.cpu().data.numpy() ids_arr.append(int(temp)) # Decode word_ids to words sampled_caption = [] for word_id in ids_arr: word = vocab.idx2word[word_id] sampled_caption.append(word) if word == '<end>': break sentence = ' '.join(sampled_caption) # Print out image and generated caption. print (sentence)
def main(args): # define transforms for normalization and data augmentation transform_augment = T.Compose([ T.RandomHorizontalFlip(), T.RandomCrop(32, padding=4)]) transform_normalize = T.Compose([ T.ToTensor(), T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # get CIFAR-10 data NUM_TRAIN = 45000 NUM_VAL = 5000 cifar10_train = dset.CIFAR10('./dataset', train=True, download=True, transform=T.Compose([transform_augment, transform_normalize])) loader_train = DataLoader(cifar10_train, batch_size=args.batch_size, sampler=ChunkSampler(NUM_TRAIN)) cifar10_val = dset.CIFAR10('./dataset', train=True, download=True, transform=transform_normalize) loader_val = DataLoader(cifar10_train, batch_size=args.batch_size, sampler=ChunkSampler(NUM_VAL, start=NUM_TRAIN)) cifar10_test = dset.CIFAR10('./dataset', train=False, download=True, transform=transform_normalize) loader_test = DataLoader(cifar10_test, batch_size=args.batch_size) # load model model = ResNet(args.n, res_option=args.res_option, use_dropout=args.use_dropout) param_count = get_param_count(model) print('Parameter count: %d' % param_count) # use gpu for training if not torch.cuda.is_available(): print('Error: CUDA library unavailable on system') return global gpu_dtype gpu_dtype = torch.cuda.FloatTensor model = model.type(gpu_dtype) # setup loss function criterion = nn.CrossEntropyLoss().cuda() # train model SCHEDULE_EPOCHS = [100, 5, 5] # divide lr by 10 after each number of epochs learning_rate = 0.1 for num_epochs in SCHEDULE_EPOCHS: print('Training for %d epochs with learning rate %f' % (num_epochs, learning_rate)) optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=args.weight_decay) for epoch in range(num_epochs): #check_accuracy(model, loader_val) check_accuracy_train(model, loader_test) print('Starting epoch %d / %d' % (epoch+1, num_epochs)) train(loader_train, model, criterion, optimizer) learning_rate *= 0.1 print('Final test accuracy:') check_accuracy(model, loader_test) print('Saving model') torch.save(model.state_dict(), 'ResNet-34_acc_train_mode')
def __init__(self, weights_path, conf_thres=0.7, nms_thres=0.5): self.conf_thres = conf_thres self.nms_thres = nms_thres model_dict = torch.load(weights_path) anchors = model_dict['anchors'].to('cuda') self.model = ResNet(anchors, Istrain=False).to('cuda') self.model.load_state_dict(model_dict['net']) self.model.eval()
def create_model(task): if task == 'mnist': model = ResNet(1, 18, 10) elif task == 'cifar10': model = ResNet(3, 18, 10) else: error(f"Unrecognised task {task}!") error("Exiting..\n") exit() return model
def main(): parameters = get_parameter() # Data print('==> Preparing dataset %s' % args.dataset) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) if args.dataset == 'cifar10': dataloader = datasets.CIFAR10 num_classes = 10 else: dataloader = datasets.CIFAR100 num_classes = 100 trainset = dataloader(root=args.dataroot, train=True, download=True, transform=transform_train) trainloader = data.DataLoader(dataset=trainset, batch_size=parameters['batch_size'], shuffle=False) testset = dataloader(root=args.dataroot, train=False, download=False, transform=transform_test) testloader = data.DataLoader(testset, batch_size=parameters['batch_size'], shuffle=False, num_workers=args.workers) # Model print("==> creating model '{}'".format("Resnet")) model = ResNet(depth=args.depth, num_classes=num_classes) model = model.cuda() print('Model on cuda') cudnn.benchmark = True print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters())/1000000.0)) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=parameters['lr'], momentum=parameters['momentum'], weight_decay=args.weight_decay) # Train and val result = 0.0 for epoch in range(parameters['epoch']): adjust_learning_rate(optimizer, epoch) train_loss, train_acc = train(trainloader, model, criterion, optimizer, epoch, use_cuda) test_loss, test_acc = test(testloader, model, criterion, epoch, use_cuda) print('Epoch[{}/{}]: LR: {:.3f}, Train loss: {:.5f}, Test loss: {:.5f}, Train acc: {:.2f}, Test acc: {:.2f}.'.format(epoch+1, parameters['epoch'], state['lr'], train_loss, test_loss, train_acc, test_acc)) report_intermediate_result(float(test_acc)) report_loss(float(test_loss)) result = test_acc # print('Rank:{} Epoch[{}/{}]: LR: {:.3f}, Train loss: {:.5f}, Train acc: {:.2f}'.format(dist.get_rank(),epoch+1, args.epochs, state['lr'],train_loss, train_acc)) report_final_result(float(result))
def build(self): block = getattr(model, self.cfg.block) self.net = ResNet(layers=self.cfg.layers, res_block=block, num_classes=self.cfg.num_classes) if torch.cuda.device_count() > 0: self.net = nn.DataParallel(self.net) print(f"Number of GPUs {torch.cuda.device_count()}") self.net.to(self.device) if self.cfg.verbose and torch.cuda.device_count() <= 1: summary(self.net, (3, 224, 224))
def get_Resnet(channel=9): model = ResNet(BasicBlock, [2, 2, 2, 2]) num_fout = model.conv1.out_channels model.conv1 = nn.Conv2d(channel, num_fout, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) model.fc = nn.Linear(model.fc.in_features, 6) model.avgpool = nn.AvgPool2d(kernel_size=(6, 1), stride=1, padding=0) return model
def resnet50(weights_path, device, rt=True): state_dict_ = torch.load(weights_path, map_location=device) state_dict_model = state_dict_['state_dict'] modified_state_dict = {} for key in state_dict_model.keys(): mod_key = key[7:] modified_state_dict.update({mod_key: state_dict_model[key]}) model = ResNet(Bottleneck, [3, 4, 6, 3], modified_state_dict) model.load_state_dict(modified_state_dict, strict=False) return model
def __init__(self, conf): print(conf) self.model = ResNet() self.model.cuda() if conf.initial: self.model.load_state_dict(torch.load("models/"+conf.model)) print('Load model_ir_se101.pth') self.milestones = conf.milestones self.loader, self.class_num = get_train_loader(conf) self.total_class = 16520 self.data_num = 285356 self.writer = SummaryWriter(conf.log_path) self.step = 0 self.paras_only_bn, self.paras_wo_bn = separate_bn_paras(self.model) if conf.meta: self.head = Arcface(embedding_size=conf.embedding_size, classnum=self.total_class) self.head.cuda() if conf.initial: self.head.load_state_dict(torch.load("models/head_op.pth")) print('Load head_op.pth') self.optimizer = RAdam([ {'params': self.paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr) self.meta_optimizer = RAdam([ {'params': self.paras_wo_bn + [self.head.kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr) self.head.train() else: self.head = dict() self.optimizer = dict() for race in races: self.head[race] = Arcface(embedding_size=conf.embedding_size, classnum=self.class_num[race]) self.head[race].cuda() if conf.initial: self.head[race].load_state_dict(torch.load("models/head_op_{}.pth".format(race))) print('Load head_op_{}.pth'.format(race)) self.optimizer[race] = RAdam([ {'params': self.paras_wo_bn + [self.head[race].kernel], 'weight_decay': 5e-4}, {'params': self.paras_only_bn} ], lr=conf.lr, betas=(0.5, 0.999)) self.head[race].train() # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True) self.board_loss_every = min(len(self.loader[race]) for race in races) // 10 self.evaluate_every = self.data_num // 5 self.save_every = self.data_num // 2 self.eval, self.eval_issame = get_val_data(conf)
class Main: def __init__(self, loadModelGen=None): os.makedirs('model/' + conf.PATH, exist_ok=True) os.makedirs('data/' + conf.PATH, exist_ok=True) self.Model = ResNet().to(conf.DEVICE) if loadModelGen == None: self.modelGen = 0 print("modelGen : ", self.modelGen) data = self_play.randomData() data = self_play.inflated(data) self.Model.fit(data, policyVias=1, valueVias=1) np.savez('data/' + conf.PATH + '/Gen' + str(self.modelGen), data[0], data[1], data[2]) torch.save(self.Model.state_dict(), 'model/' + conf.PATH + '/Gen' + str(self.modelGen)) else: self.modelGen = loadModelGen self.Model.load_state_dict( torch.load('model/' + conf.PATH + '/Gen' + str(self.modelGen))) def train(self): while True: self.modelGen += 1 if self.modelGen == 11: break print("modelGen : ", self.modelGen) data = self_play.DataGenerate(self.Model) data = self_play.inflated(data) self.Model.fit(data, policyVias=1, valueVias=1) np.savez('data/' + conf.PATH + '/Gen' + str(self.modelGen), data[0], data[1], data[2]) torch.save(self.Model.state_dict(), 'model/' + conf.PATH + '/Gen' + str(self.modelGen))
def main(args): # Image preprocessing transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.033, 0.032, 0.033), (0.027, 0.027, 0.027))]) # Load vocabulary wrapper with open(args.vocab_path, 'rb') as f: vocab = pickle.load(f) # Build Models #encoder = AttnEncoder(ResidualBlock, [3, 3, 3]) encoder = ResNet(ResidualBlock, [3, 3, 3], args.embed_size) encoder.eval() # evaluation mode (BN uses moving mean/variance) # decoder = AttnDecoderRnn(args.feature_size, args.hidden_size, # len(vocab), args.num_layers) decoder = DecoderRNN(args.embed_size, args.hidden_size, len(vocab), args.num_layers) print('load') # Load the trained model parameters encoder.load_state_dict(torch.load(args.encoder_path)) decoder.load_state_dict(torch.load(args.decoder_path)) print('load') # If use gpu if torch.cuda.is_available(): encoder.cuda(1) decoder.cuda(1) trg_bitmap_dir = args.root_path + 'bitmap/' save_directory = 'predict_base/' svg_from_out = args.root_path + save_directory + 'svg/' # svg from output caption bitmap_from_out = args.root_path + save_directory + 'bitmap/' #bitmap from out caption if not os.path.exists(bitmap_from_out): os.makedirs(bitmap_from_out) if not os.path.exists(svg_from_out): os.makedirs(svg_from_out) test_list = os.listdir(trg_bitmap_dir) for i, fname in enumerate(test_list): print(fname) test_path = trg_bitmap_dir + fname test_image = load_image(test_path, transform) image_tensor = to_var(test_image) in_sentence = gen_caption_from_image(image_tensor, encoder, decoder, vocab) print(in_sentence) image_matrix = cv2.imread(test_path) doc = gen_svg_from_predict(in_sentence.split(' '), image_matrix) with open(os.path.join(svg_from_out, fname.split('.')[0]+'.svg'), 'w+') as f: f.write(doc) cairosvg.svg2png(url=svg_from_out+ fname.split('.')[0] + '.svg', write_to= bitmap_from_out+fname)
def resume_training(weights_path, device): ''' To resume training ''' checkpoint = torch.load(weights_path, map_location=device) model = ResNet( Bottleneck, [3, 4, 6, 3], checkpoint['model_state_dict'], rt=True) model.load_state_dict(checkpoint['model_state_dict'], strict=False) optimizer = optimizer = optim.SGD(model.parameters()) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch'] cls_loss = checkpoint['cls_loss'] mec_loss = checkpoint['mec_loss'] test_loss = checkpoint['test_loss'] return model, optimizer, epoch, cls_loss, mec_loss, test_loss
def train_overview(train_dataloader, val_dataloader): global output_train, output_val output_dir = create_train_output_dir() output_train = os.path.join(output_dir, 'train.csv') output_val = os.path.join(output_dir, 'val.csv') with open(output_train, 'w') as train_csv: train_csv.write('{}\n'.format(','.join(fieldnames))) with open(output_val, 'w') as val_csv: val_csv.write('{}\n'.format(','.join(fieldnames))) print('Creating output dir {}'.format(output_dir)) print("=> creating Model ({}-{}) ...".format(args.encoder, args.decoder)) model = ResNet(args.encoder, args.decoder, args.dims, args.output_size, pre_trained=True) print("=> model created.") optimizer = torch.optim.SGD(model.parameters(), args.learning_rate, \ momentum=args.momentum, weight_decay=args.weight_decay) # model = torch.nn.DataParallel(model).cuda() # for multi-gpu training model = model.cuda() # define loss function (criterion) and optimizer if args.criterion == 'l2': criterion = criteria.MaskedL2Loss().cuda() elif args.criterion == 'l1': criterion = criteria.MaskedL1Loss().cuda() for epoch in range(args.n_epochs): utils.modify_learning_rate(optimizer, epoch, args.learning_rate) train(train_dataloader, model, criterion, optimizer, epoch) # train for one epoch result = validate(val_dataloader, model) # evaluate on validation set utils.save_checkpoint( { 'args': args, 'epoch': epoch, 'encoder': args.encoder, 'model': model, 'optimizer': optimizer, }, epoch, output_dir)
def main(learning_rate, n_batches, batch_size, n_blocks, kernel_size, residual_filters, train_dir, valid_dir, test_dir, data_shapes, _run, _log): _log.info("Assembling graph...") sampler = TFRecordSampler( train_dir=train_dir, valid_dir=valid_dir, test_dir=test_dir, data_shapes=data_shapes, batch_size=batch_size, ) network = ResNet( kernel_size=kernel_size, residual_filters=residual_filters, n_blocks=n_blocks, ) trainer = Trainer( network=network, sampler=sampler, learning_rate=learning_rate, run=_run, log=_log, ) _log.info("Graph assembled. {} trainable parameters".format(n_params())) trainer.train( n_batches=n_batches, summary_interval=5, checkpoint_interval=100, )
def load_model(exp, in_ch=None): params = next(exp.params.itertuples()) if in_ch is None: in_ch = 1 if params.dataset == 'mnist' else 3 out = 200 if params.dataset == 'tiny-imagenet-200' else 10 common_model_params = dict(out=out, downsample=params.downsample, n_filters=params.filters, dropout=params.dropout, norm=params.norm) if params.model == 'odenet': model = ODENet(in_ch, method=params.method, tol=params.tol, adjoint=params.adjoint, **common_model_params) else: model = ResNet(in_ch, **common_model_params) checkpoint = torch.load(exp.ckpt())['model'] # get best model model.load_state_dict(checkpoint) return model
def main(hparams): """ Main training routine specific for this project :param hparams: """ # ------------------------ # 1 INIT LIGHTNING MODEL # ------------------------ model = ResNet(hparams) checkpoint = ModelCheckpoint(filepath='./checkpoints/', save_top_k=3, verbose=True, monitor='val_acc', mode='max', prefix='') # ------------------------ # 2 INIT TRAINER # ------------------------ trainer = pl.Trainer(max_epochs=hparams.epochs, gpus=hparams.gpus, distributed_backend=hparams.distributed_backend, use_amp=hparams.use_16bit, checkpoint_callback=checkpoint, show_progress_bar=False, fast_dev_run=0) # ------------------------ # 3 START TRAINING # ------------------------ trainer.fit(model)
def __init__(self, n_classes, input_shape=(1, 40, 140)): # 灰度图 super(ResNet_LSTM, self).__init__() self.input_shape = input_shape self.resnet_cbam = res.resnet18_cbam(pretrained=False) self.dropout = nn.Dropout(0.25, inplace=True) self.lstm = nn.LSTM(input_size=self.infer_features(), hidden_size=128, num_layers=2, bidirectional=True) self.fc = nn.Linear(in_features=256, out_features=n_classes)
def __call__(self, x, seon): return { 1: Vgg.VGG11(seon), 2: Vgg.VGG13(seon), 3: Vgg.VGG16(seon), 4: Vgg.VGG19(seon), 5: ResNet.ResNet18(seon), 6: ResNet.ResNet34(seon), 7: ResNet.ResNet50(seon), 8: ResNet.ResNet101(seon), 9: ResNet.ResNet152(seon), 10: DenseNet.DenseNet121(seon), 11: DenseNet.DenseNet169(seon), 12: DenseNet.DenseNet201(seon), 13: DenseNet.DenseNet161(seon) }[x]
def face_train(): MAX_EPOCH = 30 LR = 0.002 net = ResNet(FACE_CLASS_NUM) if USE_GPU: net.cuda() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9) train_curve = [] for epoch in range(MAX_EPOCH): correct = 0 loss_mean = 0 total = 0 net.train() for i, data in enumerate(train_loader): inputs, labels = data if USE_GPU: inputs, labels = inputs.cuda(), labels.cuda() outputs = net(inputs) optimizer.zero_grad() loss = criterion(outputs, labels) loss.backward() optimizer.step() _, predicted = torch.max(outputs.data, 1) total += labels.size(0) if USE_GPU: correct += (predicted == labels).squeeze().sum().cpu().numpy() else: correct += (predicted == labels).squeeze().sum().numpy() loss_mean += loss.item() if (i + 1) % 20 == 0: loss_mean = loss_mean / 20 train_curve.append(loss_mean) print( 'Training: Epoch [{}/{}], Iteration[{}/{}], Loss:{:.4f}, acc:{:.4f} ' .format(epoch + 1, MAX_EPOCH, i + 1, len(train_loader), loss_mean, correct / total)) loss_mean = 0 torch.save(net, FACE_MODEL_PATH) try: torch.save(net.state_dict(), './model/face2.pkl') except Exception as e: print(e) print('error') train_x = range(len(train_curve)) train_y = train_curve plt.plot(train_x, train_y, label='Train') plt.legend(loc='upper right') plt.ylabel('loss value') plt.xlabel('Iteration') plt.show()
def __init__(self, modelGen): self.game = Game() self.model = ResNet() self.model.load_state_dict( torch.load('model/' + conf.PATH + '/Gen' + str(modelGen))) self.model.eval().cpu() self.MCTS = cdll.LoadLibrary("monte_carlo_" + conf.PATH + ".dll") self.MCTS.setC.argtypes = [c_float] self.MCTS.clear.argtypes = [] self.MCTS.SingleInit.argtypes = [POINTER(c_int)] self.MCTS.SingleMoveToLeaf.argtypes = [] self.MCTS.SingleRiseNode.argtypes = [c_float, POINTER(c_float)] self.MCTS.SingleGetAction.argtypes = [c_float] self.MCTS.SingleGetState.argtypes = [POINTER(c_int)] print("W :", self.getValue())
def setUp(self): from trainer import Trainer from model import ResNet self.model = ResNet() crit = t.nn.BCELoss() trainer = Trainer(self.model, crit, cuda=False) trainer.save_onnx('checkpoint_test.onnx')
def get_encoder(args): if args.encoder == 'resnet': encoder = ResNet(args.embed_size, ver=args.encoder_ver, attention_mechanism=args.attention) elif args.encoder == 'vgg': encoder = VGG(args.embed_size, ver=args.encoder_ver, attention_mechanism=args.attention) else: raise NameError('Not supported pretrained network') return encoder
def get_models(model_weights): model_dict = torch.load(model_weights) class_name = model_dict['class_name'] state_dict = model_dict['net'] model = ResNet(class_name=class_name) model.to('cuda') model.load_state_dict(state_dict) model.eval() return model, class_name
def main(): #データセットの作成 from torchvision.datasets import ImageFolder from data_augumentation import Compose, Resize, Scale, RandomRotation, RandomMirror width = 512 height = 512 mean = (0.5, 0.5, 0.5) std = (0.5, 0.5, 0.5) train_transform = transforms.Compose([ RandomRotation(angle=[-10,10]), RandomMirror(), Resize(width, height), transforms.ToTensor(), transforms.Normalize(mean, std) ]) val_transform = transforms.Compose([ Resize(width, height), transforms.ToTensor(), transforms.Normalize(mean, std) ]) train_images=ImageFolder( '/kw_resources/Img_classification/data/train/', transform=train_transform ) test_images=ImageFolder( '/kw_resources/Img_classification/data/val/', transform=val_transform ) train_loader=torch.utils.data.DataLoader(train_images,batch_size=12,shuffle=True, num_workers=2) test_loader=torch.utils.data.DataLoader(test_images,batch_size=12,shuffle=True, num_workers=2) from model import ResNet in_ch = 3 f_out = 32 n_ch = 37 model = ResNet(in_ch, f_out, n_ch) #モデルの学習 from train import train num_epoch = 300 up_model = train(model, num_epoch, train_loader, test_loader)
def main(): torch.manual_seed(args.seed)#设置随机种子 train_dataset = SpeakerTrainDataset(samples_per_speaker = args.samples_per_speaker)#设置训练集读取 n_classes = train_dataset.n_classes#说话人数 print('Num of classes: {}'.format(n_classes)) model = ResNet(layers=[1, 1, 1, 1], embedding_size=args.embedding_size, n_classes=n_classes, m=args.m).to(device) torchsummary.summary(model, (1,161,300)) if args.optimizer == 'sgd':#优化器使用sgd optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, dampening=args.dampening, weight_decay=args.wd) elif args.optimizer == 'adagrad':#优化器使用adagrad optimizer = torch.optim.Adagrad(model.parameters(), lr=args.lr, lr_decay=args.lr_decay, weight_decay=args.wd) else:#优化器使用adam optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.wd) criterion = AngleLoss(lambda_min=args.lambda_min, lambda_max=args.lambda_max).to(device)#loss设置 start = 1 if args.resume:#是否从之前保存的模型开始 if os.path.isfile(args.resume): print('=> loading checkpoint {}'.format(args.resume)) checkpoint = torch.load(args.resume) if args.start is not None: start = start else: start = checkpoint['epoch'] + 1 if args.load_it: criterion.it = checkpoint['it'] elif args.it is not None: criterion.it = args.it if args.load_optimizer: optimizer.load_state_dict(checkpoint['optimizer']) model.load_state_dict(checkpoint['state_dict']) else: print('=> no checkpoint found at {}'.format(args.resume)) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=1, pin_memory=True) test_dataset = SpeakerTestDataset(transform=args.transform) test_loader = DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=False, num_workers=1, pin_memory=True) for epoch in range(start, args.epochs + 1): train(epoch, model, criterion, optimizer, train_loader) if epoch % 5 == 0: test(model, test_loader)#测试 task = pd.read_csv('task/task.csv', header=None, delimiter = '[ ]', engine='python') pred = pd.read_csv(args.final_dir + 'pred.csv', engine='python') y_true = np.array(task.iloc[:, 0]) y_pred = np.array(pred.iloc[:, -1]) eer, thresh = cal_eer(y_true, y_pred) print('EER : {:.3%}'.format(eer)) print('Threshold: {:.5f}'.format(thresh))
def match(args): num_of_game, n, model_file_name, order, opponent = args device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = ResNet(ResidualBlock, [2, 2, 2, 2]).to(device) # model_file_name = "zero_final_0" load_model(model, model_file_name) if opponent is not None: model2 = ResNet(ResidualBlock, [2, 2, 2, 2]).to(device) load_model(model2, opponent) # num_of_game = 1000 num_of_win = 0 # order = 0 p_bar = trange(num_of_game, position=n) for i in p_bar: state = np.zeros((1, 32)) for turn in range(8): if turn % 2 == order: state_plane = coordinates_to_plane(state, turn, order).to(device) prob, _ = model(state_plane) action = best_shot_parm(prob) elif opponent is not None: state_plane = coordinates_to_plane(state, turn, (order+1) % 2).to(device) prob, _ = model2(state_plane) action = best_shot_parm(prob) else: # action = (2.375, 4.88, random.randint(0, 1)) action = (random.random() * 4.75, random.random() * 11.28, random.randint(0, 1)) state = sim.simulate(state, turn, action[0], action[1], action[2], 0.145)[0] if get_score(state, order) > 0: num_of_win += 1 p_bar.set_description("%.3f" % (num_of_win/(i+1))) return num_of_win / num_of_game