train_data_dup_count,
replace=True)
train_data_addon = train_data[train_data_true_sample_idx]
# make sure that all the addon have true labels
assert all([x[1] == 1 for x in train_data_addon])
# stack the addon to the original trainning data and shuffle again
train_data = np.concatenate((train_data, train_data_addon), axis=0)
train_data_size = len(train_data)
shuffle_idx = np.random.permutation(train_data_size)
train_data = train_data[shuffle_idx]
# init model
model = ConvNet()
model = model.cuda()
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=1e-5 * 2,
weight_decay=1e-2)
# train loop
# use k-fold validation
k_fold = 10
fold_size = int(train_data_size // k_fold)
for i in range(k_fold):
# split data into train/val
val_data_curr_fold = train_data[i * fold_size:(i + 1) * fold_size]
train_data_curr_fold_head = train_data[:i * fold_size]
# Specify the type of model
if model_type == 'conv':
model = ConvNet()
elif model_type == 'fully':
model = Fully()
# Set the type of gradient optimizer and the model it update
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# Choose loss function
criterion = nn.CrossEntropyLoss()
# Check if GPU is available, otherwise CPU is used
use_cuda = torch.cuda.is_available()
if use_cuda:
model.cuda()
# Four list to plot learning curve
train_loss = []
train_acc = []
validation_loss = []
validation_acc = []
# Run any number of epochs you want
ep = 10
for epoch in range(ep):
print('Epoch:', epoch)
##############
## Training ##
##############
with open('char_dict', 'rb') as f:
class_dict = pickle.load(f)
num_classes = len(class_dict)
# 读取数据
transform = transforms.Compose([
transforms.Resize((64, 64)),
transforms.ToTensor(),
])
dataset = HWDB(path=data_path, transform=transform)
print("训练集数据:", dataset.train_size)
print("测试集数据:", dataset.test_size)
trainloader, testloader = dataset.get_loader(batch_size)
net = ConvNet(num_classes)
if torch.cuda.is_available():
net = net.cuda()
net.load_state_dict(torch.load('checkpoints/handwriting_iter_009.pth'))
print('网络结构：\n')
#summary(net, input_size=(3, 64, 64), device='cuda')
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=lr)
writer = SummaryWriter(log_path)
for epoch in range(10, epochs):
train(epoch, net, criterion, optimizer, trainloader, writer=writer)
valid(epoch, net, testloader, writer=writer)
print("epoch%d 结束, 正在保存模型..." % epoch)
torch.save(net.state_dict(),
save_path + 'handwriting_iter_%03d.pth' % epoch)
# preprocess data
training_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size)
trainloader = get_batch_data(training_set, batch_size)
test_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size, traintest='TEST')
testloader = get_batch_data(test_set, batch_size)
device = torch.cuda.device(0)
capsnet = CapsuleNet(num_classes=nr_classes)
capsnet.cuda()
capsnet_optimizer = optim.Adam(capsnet.parameters())
convnet = ConvNet(num_classes = nr_classes)
convnet.cuda()
convnet_loss = torch.nn.MSELoss()
convnet_optimizer = optim.Adam(convnet.parameters())
def train_model(model, optimizer, num_epochs=10):
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
model.train()
running_loss = 0.0
running_accuracy = 0.0
for idx, (inputs, labels) in enumerate(trainloader, 0):
import cv2
import torch
from torchsummary import summary
from torchvision.transforms import ToTensor
import numpy as np
from tensorboardX import SummaryWriter
from model import ConvNet
from widerface import WIDERFaceDetection
from augmentations import SSDAugmentation
if __name__ == "__main__":
net = ConvNet()
net.load_state_dict(torch.load('no_gassuion_epoch240.pth'))
net = net.eval()
if torch.cuda.is_available():
net = net.cuda()
summary(net.cuda(), input_size=(3, 640, 640), batch_size=1, device='cuda')
WIDERFace_ROOT = r"F:\Datasets\人脸识别\WIDERFACE"
dataset = WIDERFaceDetection(WIDERFace_ROOT)
writer = SummaryWriter('eval_log')
# img = dataset.pull_image(1144)
img = cv2.imread('2.jpg')
# cv2.waitKey()
# _, img = cv2.VideoCapture(0).read()
# img = cv2.resize(img, (640, 640))
src = img.copy()
img = ToTensor()(img).unsqueeze(0)
class Wrapper(object):
"""docstring for Wrapper."""
def __init__(self, config, cont=None):
super(Wrapper, self).__init__()
with open(config, 'r') as f:
config = json.load(f)
self.config = config
self.best_path = str(self.config['model']['model_save_path'] +
self.config['name'] + '_model_best.pt')
self.model = ConvNet(config['model'])
self.continuing = False
if cont is not None:
print('loading in weights')
self.load_model(cont)
self.continuing = True
self.cuda = torch.cuda.is_available()
if self.cuda:
print('using cuda')
self.model.cuda()
def train(self):
model = self.model
config = self.config
trainloader = DataLoader(
KanjiDataset(self.config, train=True),
batch_size=config['train']['batch_size'], shuffle=True, pin_memory=True)
# self.valloader = DataLoader(
# KanjiDataset(self.config, train=False),
# batch_size=config['train']['batch_size'], pin_memory=True)
self.valset = KanjiDataset(self.config, train=False)
objective = nn.CrossEntropyLoss()
self.objective = objective
optimizer = optim.Adam(model.parameters(), lr=config['train']['learning_rate'])
# bestloss = float('Inf') if not self.continuing else self.valid()
bestacc = 0.0 if not self.continuing else self.eval()[0]
past_best = 0
max_past = 50
for e in range(config['train']['epochs']):
avgloss = 0.0
for i, (x, y) in enumerate(trainloader):
if self.cuda:
x = x.cuda(async=True)
y = y.cuda(async=True)
optimizer.zero_grad()
preds = model(x)
loss = objective(preds, y)
avgloss += loss.item()
loss.backward()
optimizer.step()
preds = None
gc.collect()
avgloss /= len(trainloader)
# vloss = self.valid()
vacc = self.eval()[0]
if e%5==0:
print('epoch: {}, loss: {:.4f}, val_acc: {:.4f}'
.format( e+1, avgloss, vacc ) )
# print('epoch: {}, loss: {:.4f}, val_loss: {:.4f}, memory: {:.4f}'
# .format(e+1, avgloss, vloss, torch.cuda.memory_allocated(0) / 1e9 ) )
# if e%20==0:
# self.print_acc()
# if vloss < bestloss:
if vacc > bestacc:
path = str(self.config['model']['model_save_path'] +
self.config['name'] + '_model_{:.4f}.pt'.format(vacc))
self.save_model(path)
self.save_model(self.best_path)
# bestloss = vloss
bestacc = vacc
past_best = 0
else:
past_best += 1
if past_best >= max_past:
print('past')
break
self.valloader = None
self.print_acc()
return
def valid(self):
loss = 0.0
for (x, y) in self.valloader:
if self.cuda:
x = x.cuda(async=True)
y = y.cuda(async=True)
loss += self.objective(self.model(x), y).item()
return loss/len(self.valloader)
def eval(self, train=False):
validset = self.valset if train else KanjiDataset(self.config, train=False)
acc = 0
conf = np.zeros((self.config['model']['classes'],
self.config['model']['classes']), dtype=np.int32)
for (x, y) in validset:
pred = self.predict(x)
acc += (pred == y)
conf[y, pred] = conf[y, pred] + 1
return acc/len(validset), conf
def print_acc(self):
acc, conf = self.eval()
print('acc:', acc)
print('conf:\n', conf)
def predict(self, image):
image = torch.unsqueeze(image, 0)
if self.cuda:
image = image.cuda(async=True)
pred = self.model(image)
pred = torch.argmax(pred[0])
return pred.item()
def save_model(self, path):
torch.save( self.model.state_dict(), path )
print('save:', path)
def load_model(self, cont):
path = self.best_path
if cont != 'cont':
path = join(self.config['model']['model_save_path'], cont)
print('loading path:', path)
self.model.load_state_dict( torch.load( path ) )
