def run(args):
if not os.path.exists(args.logdir):
os.makedirs(args.logdir)
logger = get_logger(os.path.join(args.logdir, 'main.log'))
logger.info(args)
# data
source_transform = transforms.Compose([
# transforms.Grayscale(),
transforms.ToTensor()]
)
target_transform = transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.repeat(3, 1, 1))
])
source_dataset_train = SVHN(
'./input', 'train', transform=source_transform, download=True)
target_dataset_train = MNIST(
'./input', train=True, transform=target_transform, download=True)
target_dataset_test = MNIST(
'./input', train=False, transform=target_transform, download=True)
source_train_loader = DataLoader(
source_dataset_train, args.batch_size, shuffle=True,
drop_last=True,
num_workers=args.n_workers)
target_train_loader = DataLoader(
target_dataset_train, args.batch_size, shuffle=True,
drop_last=True,
num_workers=args.n_workers)
target_test_loader = DataLoader(
target_dataset_test, args.batch_size, shuffle=False,
num_workers=args.n_workers)
# train source CNN
source_cnn = CNN(in_channels=args.in_channels).to(args.device)
if os.path.isfile(args.trained):
print("load model")
c = torch.load(args.trained)
source_cnn.load_state_dict(c['model'])
logger.info('Loaded `{}`'.format(args.trained))
else:
print("not load model")
# train target CNN
target_cnn = CNN(in_channels=args.in_channels, target=True).to(args.device)
target_cnn.load_state_dict(source_cnn.state_dict())
discriminator = Discriminator(args=args).to(args.device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(
target_cnn.encoder.parameters(),
lr=args.lr, betas=args.betas, weight_decay=args.weight_decay)
d_optimizer = optim.Adam(
discriminator.parameters(),
lr=args.lr, betas=args.betas, weight_decay=args.weight_decay)
train_target_cnn(
source_cnn, target_cnn, discriminator,
criterion, optimizer, d_optimizer,
source_train_loader, target_train_loader, target_test_loader,
args=args)
class Predictor:
def __init__(self, ckpt_path):
super().__init__()
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(256),
transforms.ToTensor()
])
self.checkpoint = torch.load(ckpt_path)
self.model = CNN()
self.model.load_state_dict(state_dict=self.checkpoint['state_dict'])
self.use_cuda = False
self.model.eval()
if torch.cuda.is_available():
self.model.cuda()
self.use_cuda = True
def run(self, path):
img = self.transform(io.imread(path))
img.unsqueeze_(0)
if self.use_cuda:
img = img.cuda()
with torch.no_grad():
pred = self.model(img)
return pred.item()
def predict(img_dir='./data/test'):
transforms = Compose([Resize(height, weight), ToTensor()])
dataset = CaptchaData(img_dir, transform=transforms)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.eval()
cnn.load_state_dict(torch.load(model_path))
for k, (img, target) in enumerate(dataset):
img = img.view(1, 3, height, weight).cuda()
target = target.view(1, 4 * 36).cuda()
output = cnn(img)
output = output.view(-1, 36)
target = target.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
target = torch.argmax(target, dim=1)
output = output.view(-1, 4)[0]
target = target.view(-1, 4)[0]
print('pred: ' + ''.join([alphabet[i] for i in output.cpu().numpy()]))
print('true: ' + ''.join([alphabet[i] for i in target.cpu().numpy()]))
plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy())
plot.show()
if k >= 10: break
def post_predict():
text = "failure"
if request.method == 'POST':
file = request.get_data()
img = Image.open(BytesIO(file)).convert('RGB')
print('宽：%d,高：%d' % (img.size[0], img.size[1]))
width = img.size[0]
height = img.size[1]
transform = Compose([Resize(height, width), ToTensor()])
img = transform(img)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.eval()
cnn.load_state_dict(torch.load(model_path, map_location='cpu'))
img = img.view(1, 3, height, width).cuda()
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, 4)[0]
text = ''.join([alphabet[i] for i in output.cpu().numpy()])
# print('pred: '+text)
# plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy())
# plot.show()
return text
class Tester:
"""
测试
"""
def __init__(self, _hparams):
self.test_loader = get_test_loader(_hparams)
self.encoder = CNN().to(DEVICE)
self.decoder = RNN(fea_dim=_hparams.fea_dim,
embed_dim=_hparams.embed_dim,
hid_dim=_hparams.hid_dim,
max_sen_len=_hparams.max_sen_len,
vocab_pkl=_hparams.vocab_pkl).to(DEVICE)
self.test_cap = _hparams.test_cap
def testing(self, save_path, test_path):
"""
测试
:param save_path: 模型的保存地址
:param test_path: 保存测试过程生成句子的路径
:return:
"""
print('*' * 20, 'test', '*' * 20)
self.load_models(save_path)
self.set_eval()
sen_json = []
with torch.no_grad():
for val_step, (img, img_id) in tqdm(enumerate(self.test_loader)):
img = img.to(DEVICE)
features = self.encoder.forward(img)
sens, _ = self.decoder.sample(features)
sen_json.append({'image_id': int(img_id), 'caption': sens[0]})
with open(test_path, 'w') as f:
json.dump(sen_json, f)
result = coco_eval(self.test_cap, test_path)
for metric, score in result:
print(metric, score)
def load_models(self, save_path):
ckpt = torch.load(save_path,
map_location={'cuda:2': 'cuda:0'
}) # 映射是因为解决保存模型的卡与加载模型的卡不一致的问题
encoder_state_dict = ckpt['encoder_state_dict']
self.encoder.load_state_dict(encoder_state_dict)
decoder_state_dict = ckpt['decoder_state_dict']
self.decoder.load_state_dict(decoder_state_dict)
def set_eval(self):
self.encoder.eval()
self.decoder.eval()
def load_net():
global model_net
model_net = CNN(num_class=len(alphabet),
num_char=int(numchar),
width=width,
height=height)
if use_gpu:
model_net = model_net.cuda()
model_net.eval()
model_net.load_state_dict(torch.load(model_path))
else:
model_net.eval()
model_net.load_state_dict(torch.load(model_path, map_location='cpu'))
def main():
parser = argparse.ArgumentParser(description="FGSM")
parser.add_argument("--device", type=str, default="cuda")
parser.add_argument("--data_root", type=str, default="./data")
parser.add_argument("--data_name", type=str, default="mnist")
parser.add_argument("--image_size", type=int, default=32)
parser.add_argument("--image_channels", type=int, default=1)
parser.add_argument("--epsilon", type=int, default=0.1)
opt = parser.parse_args()
model = CNN(opt.image_size, opt.image_channels).to(opt.device)
model.load_state_dict(torch.load("./weights/cnn.pth"))
test(model, opt)
def init():
global model, device
try:
model_path = Model.get_model_path('pytorch_mnist')
except:
model_path = 'model.pth'
device = torch.device('cpu')
model = CNN()
model.load_state_dict(torch.load(model_path, map_location=device))
model.to(device)
model.eval()
def init():
global model, device
try:
model_path = Model.get_model_path('pytorch_mnist')
except:
model_path = 'model.pth'
device = torch.device('cpu')
model = CNN()
model.load_state_dict(torch.load(model_path, map_location=device))
model.to(device)
model.eval()
print('Initialized model "{}" at {}'.format(model_path,
datetime.datetime.now()))
def predict(img_dir=Path('./captcha')):
transforms = Compose([ToTensor()])
for i in img_dir.glob("*png"):
print(i.name)
img = img_loader('./captcha/%s' % i.name)
img = transforms(img)
cnn = CNN()
cnn.load_state_dict(torch.load(model_path))
img = img.view(1, 3, 36, 120)
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, num_class)[0]
pred = ''.join([alphabet[i] for i in output.cpu().numpy()])
print(pred)
args.window_dim, len(data["lbl2idx"]), args.dp, emb)
if args.fix_emb:
model.embedding.weight.requires_grad = False
loss = torch.nn.CrossEntropyLoss()
optim = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.l2)
if args.cuda:
model.cuda()
trainModel(args, model, loss, optim, trainData, valData)
if args.submit:
# load the best model saved during training
model.load_state_dict(
torch.load(args.path_savedir +
"{}_{}.model".format(args.model, args.epochs)))
model.eval()
preds_val = predict(model, valData)
save_prediction(
args.path_savedir + "{}_{}.val".format(args.model, args.epochs),
preds_val, data["idx2lbl"])
testData = Dataset(data["test"], args.batch_size, args.cuda)
preds_test = predict(model, testData)
save_prediction(
args.path_savedir + "{}_{}.test".format(args.model, args.epochs),
preds_test, data["idx2lbl"])
def main(args):
# hyperparameters
batch_size = args.batch_size
num_workers = 2
# Image Preprocessing
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
vocab = load_vocab()
loader = get_basic_loader(dir_path=os.path.join(args.image_path),
transform=transform,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
# Build the models
embed_size = args.embed_size
num_hiddens = args.num_hidden
checkpoint_path = 'checkpoints'
encoder = CNN(embed_size)
decoder = RNN(embed_size,
num_hiddens,
len(vocab),
1,
rec_unit=args.rec_unit)
encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models(
args.checkpoint_file)
encoder.load_state_dict(encoder_state_dict)
decoder.load_state_dict(decoder_state_dict)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
# Train the Models
try:
results = []
with torch.no_grad():
for step, (images, image_ids) in enumerate(tqdm(loader)):
images = utils.to_var(images)
features = encoder(images)
captions = beam_sample(decoder, features)
# captions = decoder.sample(features)
captions = captions.cpu().data.numpy()
captions = [
utils.convert_back_to_text(cap, vocab) for cap in captions
]
captions_formatted = [{
'image_id': int(img_id),
'caption': cap
} for img_id, cap in zip(image_ids, captions)]
results.extend(captions_formatted)
print('Sample:', captions_formatted[0])
except KeyboardInterrupt:
print('Ok bye!')
finally:
import json
file_name = 'captions_model.json'
with open(file_name, 'w') as f:
json.dump(results, f)
def run(args):
args.logdir = args.logdir + args.mode
args.trained = args.trained + args.mode + '/best_model.pt'
if not os.path.exists(args.logdir):
os.makedirs(args.logdir)
logger = get_logger(os.path.join(args.logdir, 'main.log'))
logger.info(args)
# data
# source_transform = transforms.Compose([
# # transforms.Grayscale(),
# transforms.ToTensor()]
# )
# target_transform = transforms.Compose([
# transforms.Resize(32),
# transforms.ToTensor(),
# transforms.Lambda(lambda x: x.repeat(3, 1, 1))
# ])
# source_dataset_train = SVHN(
# './input', 'train', transform=source_transform, download=True)
# target_dataset_train = MNIST(
# './input', train=True, transform=target_transform, download=True)
# target_dataset_test = MNIST(
# './input', train=False, transform=target_transform, download=True)
# source_train_loader = DataLoader(
# source_dataset_train, args.batch_size, shuffle=True,
# drop_last=True,
# num_workers=args.n_workers)
# target_train_loader = DataLoader(
# target_dataset_train, args.batch_size, shuffle=True,
# drop_last=True,
# num_workers=args.n_workers)
# target_test_loader = DataLoader(
# target_dataset_test, args.batch_size, shuffle=False,
# num_workers=args.n_workers)
batch_size = 128
if args.mode == 'm2mm':
source_dataset_name = 'MNIST'
target_dataset_name = 'mnist_m'
source_image_root = os.path.join('dataset', source_dataset_name)
target_image_root = os.path.join('dataset', target_dataset_name)
image_size = 28
img_transform_source = transforms.Compose([
transforms.Resize(image_size),
transforms.ToTensor(),
transforms.Normalize(mean=(0.1307, ), std=(0.3081, ))
])
img_transform_target = transforms.Compose([
transforms.Resize(image_size),
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
dataset_source = datasets.MNIST(root='dataset',
train=True,
transform=img_transform_source,
download=True)
train_list = os.path.join(target_image_root,
'mnist_m_train_labels.txt')
dataset_target_train = GetLoader(data_root=os.path.join(
target_image_root, 'mnist_m_train'),
data_list=train_list,
transform=img_transform_target)
test_list = os.path.join(target_image_root, 'mnist_m_test_labels.txt')
dataset_target_test = GetLoader(data_root=os.path.join(
target_image_root, 'mnist_m_test'),
data_list=test_list,
transform=img_transform_target)
elif args.mode == 's2u':
dataset_source = svhn.SVHN('./data/svhn/',
split='train',
download=True,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5))
]))
dataset_target_train = usps.USPS('./data/usps/',
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, ),
(0.5, ))
]))
dataset_target_test = usps.USPS('./data/usps/',
train=False,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, ),
(0.5, ))
]))
source_dataset_name = 'svhn'
target_dataset_name = 'usps'
source_train_loader = torch.utils.data.DataLoader(dataset=dataset_source,
batch_size=batch_size,
shuffle=True,
num_workers=8)
target_train_loader = torch.utils.data.DataLoader(
dataset=dataset_target_train,
batch_size=batch_size,
shuffle=True,
num_workers=8)
target_test_loader = torch.utils.data.DataLoader(
dataset=dataset_target_test,
batch_size=batch_size,
shuffle=False,
num_workers=8)
# train source CNN
source_cnn = CNN(in_channels=args.in_channels).to(args.device)
if os.path.isfile(args.trained):
print("load model")
c = torch.load(args.trained)
source_cnn.load_state_dict(c['model'])
logger.info('Loaded `{}`'.format(args.trained))
else:
print("not load model")
# train target CNN
target_cnn = CNN(in_channels=args.in_channels, target=True).to(args.device)
target_cnn.load_state_dict(source_cnn.state_dict())
discriminator = Discriminator(args=args).to(args.device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(target_cnn.encoder.parameters(), lr=args.lr)
# optimizer = optim.Adam(
# target_cnn.encoder.parameters(),
# lr=args.lr, betas=args.betas, weight_decay=args.weight_decay)
d_optimizer = optim.Adam(discriminator.parameters(), lr=args.lr)
# d_optimizer = optim.Adam(
# discriminator.parameters(),
# lr=args.lr, betas=args.betas, weight_decay=args.weight_decay)
train_target_cnn(source_cnn,
target_cnn,
discriminator,
criterion,
optimizer,
d_optimizer,
source_train_loader,
target_train_loader,
target_test_loader,
args=args)
N_FILTERS = 100
FILTER_SIZES = [3, 4, 5]
OUTPUT_DIM = 1
DROPOUT = 0.5
model = CNN(INPUT_DIM, EMBEDDING_DIM, N_FILTERS, FILTER_SIZES, OUTPUT_DIM,
DROPOUT)
# def get_preds(model, iterator):
# yield pred
ck1 = time.time()
print '1: %.3f' % (ck1 - start)
model.load_state_dict(torch.load('pretrained_model.pt'))
import pdb
pdb.set_trace()
model.eval()
all_preds = np.zeros(len(test_data))
all_ids = np.zeros(len(test_data))
all_labels = np.zeros(len(test_data))
with torch.no_grad():
i = 0
for batch in test_iterator:
predictions = model(batch.text).squeeze(1)
for j, pred in enumerate(predictions):
import torch.nn as nn
from torchvision.transforms.functional import to_tensor
from torchvision.transforms import Compose, ToTensor
from datasets import CaptchaData
from models import CNN
from PIL import Image
source = [str(i) for i in range(0, 10)]
source += [chr(i) for i in range(97, 97 + 26)]
model_path = './model.pth'
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.eval()
cnn.load_state_dict(torch.load(model_path))
else:
cnn.eval()
cnn.load_state_dict(torch.load(model_path, map_location='cpu'))
# img_path：单张图片路径
def captchaByPath(img_path):
img = Image.open(img_path)
img = to_tensor(img)
if torch.cuda.is_available():
img = img.view(1, 3, 32, 120).cuda()
else:
img = img.view(1, 3, 32, 120)
output = cnn(img)
output = output.view(-1, 36)
class Solver(object):
def __init__(self, config, data_loader):
self.config = config
self.data_loader = data_loader
def build(self, is_train):
if torch.cuda.is_available():
self.model = nn.DataParallel(CNN(self.config)).cuda()
else:
self.model = CNN(self.config)
self.loss_fn = self.config.loss_fn()
if is_train:
self.model.train()
self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr)
else:
if torch.cuda.is_available():
self.model = self.model.module
self.model.eval()
def save(self, ckpt_path):
"""Save model parameters"""
print('Save parameters at ', ckpt_path)
if torch.cuda.is_available():
torch.save(self.model.module.state_dict(), ckpt_path)
else:
torch.save(self.model.state_dict(), ckpt_path)
def load(self, ckpt_path=None, epoch=None):
"""Load model parameters"""
if not (ckpt_path or epoch):
epoch = self.config.epochs
if epoch:
ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl')
print('Load parameters from ', ckpt_path)
print (self.model)
self.model.load_state_dict(torch.load(ckpt_path))
def train_once(self):
loss_history = []
for batch_i, batch in enumerate(tqdm(self.data_loader)):
text, label = batch.text, batch.label
if torch.cuda.is_available():
text = text.cuda()
label = label.cuda()
text.data.t_()
logit = self.model(text)
average_batch_loss = self.loss_fn(logit, label)
loss_history.append(average_batch_loss.item())
self.optimizer.zero_grad()
average_batch_loss.backward()
self.optimizer.step()
epoch_loss = np.mean(loss_history)
return epoch_loss
def train(self):
"""Train model with training data"""
for epoch in tqdm(range(self.config.epochs)):
loss_history = []
for batch_i, batch in enumerate(tqdm(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
if torch.cuda.is_available():
text = text.cuda()
label = label.cuda()
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(average_batch_loss.item()) # Variable -> Tensor
# Flush out remaining gradient
self.optimizer.zero_grad()
# Backpropagation
average_batch_loss.backward()
# Gradient descent
self.optimizer.step()
# Log intermediate loss
if (epoch + 1) % self.config.log_every_epoch == 0:
epoch_loss = np.mean(loss_history)
log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.4f}\n'
print(log_str)
# Save model parameters
if (epoch + 1) % self.config.save_every_epoch == 0:
ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch+1}.pkl')
self.save(ckpt_path)
def eval(self):
"""Evaluate model from text data"""
n_total_data = 0
n_correct = 0
loss_history = []
'''
import ipdb
ipdb.set_trace()
'''
for _, batch in enumerate(tqdm(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
if torch.cuda.is_available():
text = text.cuda()
label = label.cuda()
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(average_batch_loss.item()) # Variable -> Tensor
# Calculate accuracy
n_total_data += len(label)
# [batch_size]
_, prediction = logit.max(1)
n_correct += (prediction == label).sum().data
epoch_loss = np.mean(loss_history)
accuracy = n_correct.item() / float(n_total_data)
print(f'Loss: {epoch_loss:.2f}')
print(f'Accuracy: {accuracy}')
return epoch_loss, accuracy
def inference(self, text):
text = Variable(torch.LongTensor([text]))
# [batch_size, 2]
logit = self.model(text)
_, prediction = torch.max(logit)
return prediction
def train_eval(self):
# Set this variable to your MLflow server's DNS name
mlflow_server = '172.23.147.124'
# Tracking URI
mlflow_tracking_URI = 'http://' + mlflow_server + ':5000'
print ("MLflow Tracking URI: %s" % (mlflow_tracking_URI))
with mlflow.start_run():
for key, value in vars(self.config).items():
mlflow.log_param(key, value)
'''
output_dir = 'mlflow_logs'
if not os.path.exists(output_dir):
os.mkdir(output_dir)
'''
for epoch in tqdm(range(self.config.epochs)):
# print out active_run
print("Active Run ID: %s, Epoch: %s \n" % (mlflow.active_run(), epoch))
train_loss = self.train_once()
mlflow.log_metric('train_loss', train_loss)
val_loss, val_acc = self.eval()
mlflow.log_metric('val_loss', val_loss)
mlflow.log_metric('val_acc', val_acc)
# Finish run
mlflow.end_run(status='FINISHED')
def main(args):
# hyperparameters
batch_size = args.batch_size
num_workers = 1
# Image Preprocessing
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
# load COCOs dataset
IMAGES_PATH = 'data/train2014'
CAPTION_FILE_PATH = 'data/annotations/captions_train2014.json'
vocab = load_vocab()
train_loader = get_coco_data_loader(path=IMAGES_PATH,
json=CAPTION_FILE_PATH,
vocab=vocab,
transform=transform,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
IMAGES_PATH = 'data/val2014'
CAPTION_FILE_PATH = 'data/annotations/captions_val2014.json'
val_loader = get_coco_data_loader(path=IMAGES_PATH,
json=CAPTION_FILE_PATH,
vocab=vocab,
transform=transform,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
losses_val = []
losses_train = []
# Build the models
ngpu = 1
initial_step = initial_epoch = 0
embed_size = args.embed_size
num_hiddens = args.num_hidden
learning_rate = 1e-3
num_epochs = 3
log_step = args.log_step
save_step = 500
checkpoint_dir = args.checkpoint_dir
encoder = CNN(embed_size)
decoder = RNN(embed_size,
num_hiddens,
len(vocab),
1,
rec_unit=args.rec_unit)
# Loss
criterion = nn.CrossEntropyLoss()
if args.checkpoint_file:
encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models(
args.checkpoint_file, args.sample)
initial_step, initial_epoch, losses_train, losses_val = meta
encoder.load_state_dict(encoder_state_dict)
decoder.load_state_dict(decoder_state_dict)
else:
params = list(decoder.parameters()) + list(
encoder.linear.parameters()) + list(encoder.batchnorm.parameters())
optimizer = torch.optim.Adam(params, lr=learning_rate)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
if args.sample:
return utils.sample(encoder, decoder, vocab, val_loader)
# Train the Models
total_step = len(train_loader)
try:
for epoch in range(initial_epoch, num_epochs):
for step, (images, captions,
lengths) in enumerate(train_loader, start=initial_step):
# Set mini-batch dataset
images = utils.to_var(images, volatile=True)
captions = utils.to_var(captions)
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
# Forward, Backward and Optimize
decoder.zero_grad()
encoder.zero_grad()
if ngpu > 1:
# run on multiple GPU
features = nn.parallel.data_parallel(
encoder, images, range(ngpu))
outputs = nn.parallel.data_parallel(
decoder, features, range(ngpu))
else:
# run on single GPU
features = encoder(images)
outputs = decoder(features, captions, lengths)
train_loss = criterion(outputs, targets)
losses_train.append(train_loss.data[0])
train_loss.backward()
optimizer.step()
# Run validation set and predict
if step % log_step == 0:
encoder.batchnorm.eval()
# run validation set
batch_loss_val = []
for val_step, (images, captions,
lengths) in enumerate(val_loader):
images = utils.to_var(images, volatile=True)
captions = utils.to_var(captions, volatile=True)
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
features = encoder(images)
outputs = decoder(features, captions, lengths)
val_loss = criterion(outputs, targets)
batch_loss_val.append(val_loss.data[0])
losses_val.append(np.mean(batch_loss_val))
# predict
sampled_ids = decoder.sample(features)
sampled_ids = sampled_ids.cpu().data.numpy()[0]
sentence = utils.convert_back_to_text(sampled_ids, vocab)
print('Sample:', sentence)
true_ids = captions.cpu().data.numpy()[0]
sentence = utils.convert_back_to_text(true_ids, vocab)
print('Target:', sentence)
print(
'Epoch: {} - Step: {} - Train Loss: {} - Eval Loss: {}'
.format(epoch, step, losses_train[-1], losses_val[-1]))
encoder.batchnorm.train()
# Save the models
if (step + 1) % save_step == 0:
utils.save_models(encoder, decoder, optimizer, step, epoch,
losses_train, losses_val, checkpoint_dir)
utils.dump_losses(
losses_train, losses_val,
os.path.join(checkpoint_dir, 'losses.pkl'))
except KeyboardInterrupt:
pass
finally:
# Do final save
utils.save_models(encoder, decoder, optimizer, step, epoch,
losses_train, losses_val, checkpoint_dir)
utils.dump_losses(losses_train, losses_val,
os.path.join(checkpoint_dir, 'losses.pkl'))
if MODEL == 'CNN':
from models import CNN
model = CNN()
elif MODEL == 'MLP':
from models import MLP
model = MLP()
else:
raise NotImplementedError("You need to choose among [CNN, MLP].")
trained_model = torch.load(
'{}.pt'.format(MODEL)) # train_20190316_1 에서 저장한 가중치 파일 mlp.pt를 불러옴
state_dict = trained_model.state_dict(
) # 훈련된 모델을 불러온 trained_model 의 상태(weight, bias)를 state_dict로 저장
# dictionary 데이터이므로 state_dict.keys(), .values(), .items() 등으로 읽을 수 있음
model.load_state_dict(
state_dict) # MLP 클래스의 모델 구조를 가진 mlp 객체에 state_dict의 가중치&바이어스를 입력함
nb_correct_answers = 0 # 정답을 맞춘 갯수를 저장하기 위한 객체
for data in data_loader: # data 객체로 data_loader의 성분을 불러옴
input, label = data[0], data[1] # data의 인풋과 라벨을 불러옴
input = input.view(input.shape[0],
-1) if model == 'MLP' else input # 인풋 데이터를 1차원 행렬로 만듬
# [batch size, channel*height*weight]
classification_results = model(
input) # mlp.pt의 가중치를 입력받은 MLP 클래스의 인스턴스 mlp 에 인풋을 입력
nb_correct_answers += torch.eq(classification_results.argmax(),
label).sum() # torch.eq(x,y): x,y가 같으면 1 출력
# .sum을 통해 한 batch 내에서 맞춘 갯수를 출력. .sum() 없으면 batch_size의 행렬에 각 성분마다 정답이면1, 정답이 아니면 0 돌려줌.([0,0,1,1,0,0,1])
print("Average acc.: {} %.".format(
float(nb_correct_answers) / len(data_loader) * 100)) # 정답률 출력
full_test_cm = get_cm(torch.Tensor(true_labels), torch.Tensor(predictions))
msg = 'Finished Training. Test Accuracy : {:.2f} Mean Loss : {:.2f}'.format(
(full_test_cm.diag().sum() / full_test_cm.sum()).item(),
full_test_loss)
print(msg)
logging.info(msg)
#save model
if True:
torch.save(
{
'epoch': epoch,
'model_state_dict': network.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
}, r"src/saved_models/model2.pkl")
#load example
checkpoint = torch.load(r"src/saved_models/model2.pkl")
network.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']
#analyze results
activity_labels = pd.read_csv("input/LabelMap.csv", index_col=0)
test_df = pd.DataFrame(full_test_cm.long().numpy(),
columns=activity_labels.Activity,
index=activity_labels.Activity)
test_df.to_csv('src/ConfusionMatrixTest__lr_scheduler.csv')
args.num_filters) + "_" + str(args.batch_size) + "_" + str(
args.rate) + ".model"
if args.gpu:
model = model.cuda()
# Training setup
L = t.nn.CrossEntropyLoss()
optimizer = t.optim.Adam(model.parameters(), lr=args.learn_rate)
if not os.path.exists("models"):
os.makedirs("models")
# load to continue with pre-existing model
if os.path.exists(fname):
model.load_state_dict(t.load(fname))
print("Successfully loaded previous model " + str(fname))
# start with a model defined on 0
# train_mix, test, train_data, train_labels = dataFetch()
# # select only 0 category
# train_dataset = customDataset(train_data[0], train_labels[0])
#
# # define train and test as DataLoaders
# train_loader = t.utils.data.DataLoader(dataset=train_dataset,
# batch_size=args.batch_size,
# shuffle=True)
# test_loader = test
train_data, test_data = dataFetch(dset=args.data)
return {
'loss': losses.avg,
'acc': acc,
}
class ARG:
def __init__(self):
self.device = 'cuda:0'
if __name__ == "__main__":
args = ARG()
target_cnn = CNN(in_channels=3, target=True).to(args.device)
c = torch.load('outputs/garbage1/best_model.pt')
target_cnn.load_state_dict(c['model'])
target_transform = transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.repeat(3, 1, 1))
])
criterion = nn.CrossEntropyLoss()
target_dataset_test = MNIST('./input',
train=False,
transform=target_transform,
download=True)
target_test_loader = DataLoader(target_dataset_test,
128,
shuffle=False,
num_workers=4)
print(len(target_test_loader))
def train():
transforms = Compose([ToTensor()])
train_dataset = CaptchaData('./data/train', transform=transforms)
train_data_loader = DataLoader(train_dataset,
batch_size=batch_size,
num_workers=0,
shuffle=True,
drop_last=True)
test_data = CaptchaData('./data/test', transform=transforms)
test_data_loader = DataLoader(test_data,
batch_size=batch_size,
num_workers=0,
shuffle=True,
drop_last=True)
cnn = CNN()
if torch.cuda.is_available():
cnn.cuda()
if restor:
cnn.load_state_dict(torch.load(model_path))
# freezing_layers = list(cnn.named_parameters())[:10]
# for param in freezing_layers:
# param[1].requires_grad = False
# print('freezing layer:', param[0])
optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr)
criterion = nn.MultiLabelSoftMarginLoss()
for epoch in range(max_epoch):
start_ = time.time()
loss_history = []
acc_history = []
cnn.train()
for img, target in train_data_loader:
img = Variable(img)
target = Variable(target)
if torch.cuda.is_available():
img = img.cuda()
target = target.cuda()
output = cnn(img)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = calculat_acc(output, target)
acc_history.append(acc)
loss_history.append(loss)
print('train_loss: {:.4}|train_acc: {:.4}'.format(
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
loss_history = []
acc_history = []
cnn.eval()
for img, target in test_data_loader:
img = Variable(img)
target = Variable(target)
if torch.cuda.is_available():
img = img.cuda()
target = target.cuda()
output = cnn(img)
acc = calculat_acc(output, target)
acc_history.append(acc)
loss_history.append(float(loss))
print('test_loss: {:.4}|test_acc: {:.4}'.format(
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_))
torch.save(cnn.state_dict(), model_path)
class Solver(object):
def __init__(self, config, data_loader):
self.config = config
self.data_loader = data_loader
def build(self, is_train):
self.model = CNN(self.config)
self.loss_fn = self.config.loss_fn()
if is_train:
self.model.train()
self.optimizer = self.config.optimizer(self.model.parameters(),
lr=self.config.lr)
else:
self.model.eval()
def train(self):
for epoch in tqdm(range(self.config.epochs)):
loss_history = []
for batch_i, batch in enumerate(tqdm(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(
average_batch_loss.data[0]) # Variable -> Tensor
# Flush out remaining gradient
self.optimizer.zero_grad()
# Backpropagation
average_batch_loss.backward()
# Gradient descent
self.optimizer.step()
# Log intermediate loss
if (epoch + 1) % self.config.log_every_epoch == 0:
epoch_loss = np.mean(loss_history)
log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.2f}\n'
print(log_str)
# Save model parameters
if (epoch + 1) % self.config.save_every_epoch == 0:
ckpt_path = os.path.join(self.config.save_dir,
f'epoch-{epoch+1}.pkl')
print('Save parameters at ', ckpt_path)
torch.save(self.model.state_dict(), ckpt_path)
def eval(self, epoch=None):
# Load model parameters
if not isinstance(epoch, int):
epoch = self.config.epochs
ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl')
print('Load parameters from ', ckpt_path)
self.model.load_state_dict(torch.load(ckpt_path))
loss_history = []
for _, batch in tqdm(enumerate(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(
average_batch_loss.data[0]) # Variable -> Tensor
epoch_loss = np.mean(loss_history)
print('Loss: {epoch_loss:.2f}')
if device == "cuda":
print(
"Using GPU. Setting default tensor type to torch.cuda.FloatTensor")
torch.set_default_tensor_type("torch.cuda.FloatTensor")
else:
print("Using CPU. Setting default tensor type to torch.FloatTensor")
torch.set_default_tensor_type("torch.FloatTensor")
"""Converting model to specified hardware and format"""
acoustic_cfg_json = json.load(
open(args.acoustic_model.replace(".torch", ".json"), "r"))
acoustic_cfg = AcousticConfig.from_json(acoustic_cfg_json)
acoustic_model = CNN(acoustic_cfg)
acoustic_model.float().to(device)
try:
acoustic_model.load_state_dict(torch.load(args.acoustic_model))
except:
print(
"Failed to load model from {} without device mapping. Trying to load with mapping to {}"
.format(args.acoustic_model, device))
acoustic_model.load_state_dict(
torch.load(args.acoustic_model, map_location=device))
linguistic_cfg_json = json.load(
open(args.linguistic_model.replace(".torch", ".json"), "r"))
linguistic_cfg = LinguisticConfig.from_json(linguistic_cfg_json)
linguistic_model = AttentionModel(linguistic_cfg)
linguistic_model.float().to(device)
try:
linguistic_model.load_state_dict(torch.load(args.linguistic_model))
pickle.dump(params, open(init_params_file, 'wb'))
# initialize accumulators.
current_epoch = 1
batch_step_count = 1
time_used_global = 0.0
checkpoint = 1
# load lastest model to resume training
model_list = os.listdir(model_dir)
if model_list:
print('Loading lastest checkpoint...')
state = load_model(model_dir, model_list)
encoder.load_state_dict(state['encoder'])
decoder.load_state_dict(state['decoder'])
optimizer.load_state_dict(state['optimizer'])
current_epoch = state['epoch'] + 1
time_used_global = state['time_used_global']
batch_step_count = state['batch_step_count']
for group in optimizer.param_groups:
group['lr'] = 0.0000001
group['weight_decay'] = 0.0
for param in encoder.parameters():
param.requires_grad_(requires_grad=True)
BATCH_SIZE = 16
app = Flask(__name__,
static_folder="./backend/static",
template_folder="./backend/templates")
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
bootstrap = Bootstrap(app)
# 处理跨域请求
cors = CORS(app, resources={r"/*": {"origins": "*"}})
class2index = json.load(open("class_index.json"))
index2class = {v: k for k, v in class2index.items()}
# 在此处声明，保证模型只在app初始化时加载
device = torch.device('cpu')
model = CNN()
model.load_state_dict(torch.load('pickles/cnn.pkl'))
model.to(device=device)
trans = Compose([ToTensor(), PaddingSame2d(seq_len=224, value=0)])
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
def transform_audio(audio_bytes):
feat = get_mfcc(audio_bytes)
feat = trans(feat)
return feat
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
]))
target_test_loader = torch.utils.data.DataLoader(
dataset=dataset_target_test,
batch_size=batch_size,
shuffle=False,
num_workers=8
)
checkpoint = torch.load(args.base_classifier)
base_classifier = CNN(in_channels=3, target=True).to(device)
base_classifier.load_state_dict(checkpoint['model'])
# create the smooothed classifier g
smoothed_classifier = Smooth(base_classifier, num_classes= 10, sigma=args.sigma)
# prepare output file
# f = open(args.outfile, 'w')
# print("idx\tlabel\tpredict\tradius\tcorrect\ttime", file=f, flush=True)
# iterate through the dataset
n_total = 0
n_correct = 0
thresh_list = [0,0.5,1.0,1.5,2.0,2.5,3.0]
correct_list = [0]*7
for i,data in enumerate(target_test_loader):
if i % 100 == 0:
from models import CNN
from datasets import img_loader
from torchvision.transforms import Compose, ToTensor
from train import num_class
from pathlib import Path
model_path = './checkpoints/model.pth'
source = [str(i) for i in range(0, 10)]
source += [chr(i) for i in range(97, 97 + 26)]
alphabet = ''.join(source)
transforms = Compose([ToTensor()])
img = img_loader('captcha_test/captcha_crop.png')
img = transforms(img)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.load_state_dict(torch.load(model_path))
print("---------")
img = img.view(1, 3, 36, 120).cuda()
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, num_class)[0]
pred = ''.join([alphabet[i] for i in output.cpu().numpy()])
print(pred)
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 25 12:01:40 2020
@author: Ernest Namdar
Ref:
https://github.com/onnx/tutorials/blob/master/tutorials/PytorchTensorflowMnist.ipynb
"""
from torch.autograd import Variable
import torch
from models import CNN
# Load the trained model
PyTorch_model = CNN()
PyTorch_model.load_state_dict(torch.load("./CNN_State.pt"))
# Export the trained model to ONNX
dummy_input = Variable(torch.randn(1, 1, 28, 28)) # one single-channel 28x28 picture will be the input to the model
torch.onnx.export(PyTorch_model, dummy_input, "./CNN.onnx")
class Solver(object):
def __init__(self, config, data_loader):
self.config = config
self.data_loader = data_loader
def build(self, is_train):
self.model = CNN(self.config)
self.loss_fn = self.config.loss_fn()
if is_train:
self.model.train()
self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr)
else:
self.model.eval()
def save(self, ckpt_path):
"""Save model parameters"""
print('Save parameters at ', ckpt_path)
torch.save(self.model.state_dict(), ckpt_path)
def load(self, ckpt_path=None, epoch=None):
"""Load model parameters"""
if not (ckpt_path or epoch):
epoch = self.config.epochs
if epoch:
ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl')
print('Load parameters from ', ckpt_path)
self.model.load_state_dict(torch.load(ckpt_path))
def train(self):
"""Train model with training data"""
for epoch in tqdm(range(self.config.epochs)):
loss_history = []
for batch_i, batch in enumerate(tqdm(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(average_batch_loss.data[0]) # Variable -> Tensor
# Flush out remaining gradient
self.optimizer.zero_grad()
# Backpropagation
average_batch_loss.backward()
# Gradient descent
self.optimizer.step()
# Log intermediate loss
if (epoch + 1) % self.config.log_every_epoch == 0:
epoch_loss = np.mean(loss_history)
log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.2f}\n'
print(log_str)
# Save model parameters
if (epoch + 1) % self.config.save_every_epoch == 0:
ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch+1}.pkl')
self.save(ckpt_path)
def eval(self):
"""Evaluate model from text data"""
n_total_data = 0
n_correct = 0
loss_history = []
import ipdb
ipdb.set_trace()
for _, batch in enumerate(tqdm(self.data_loader)):
# text: [max_seq_len, batch_size]
# label: [batch_size]
text, label = batch.text, batch.label
# [batch_size, max_seq_len]
text.data.t_()
# [batch_size, 2]
logit = self.model(text)
# Calculate loss
average_batch_loss = self.loss_fn(logit, label) # [1]
loss_history.append(average_batch_loss.data[0]) # Variable -> Tensor
# Calculate accuracy
n_total_data += len(label)
# [batch_size]
_, prediction = logit.max(1)
n_correct += (prediction == label).sum().data
epoch_loss = np.mean(loss_history)
accuracy = n_correct / n_total_data
print(f'Loss: {epoch_loss:.2f}')
print(f'Accuracy: {accuracy}')
def inference(self, text):
text = Variable(torch.LongTensor([text]))
# [batch_size, 2]
logit = self.model(text)
_, prediction = torch.max(logit)
return prediction
