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
