def train_net(configs):
model = build_model(configs.backbone,
num_classes=configs.Num_Classes,
pretrained=configs.Pretrained)
#print(model)
optimizer = build_optimizer(model.parameters(), configs)
criterion = nn.CrossEntropyLoss()
if configs.cuda:
device = torch.device("cuda")
model.to(device)
criterion.to(device)
if configs.img_aug:
imgaug = transforms.Compose([
transforms.RandomHorizontalFlip(0.5),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=configs.mean, std=configs.std),
])
train_set = datasets.ImageFolder(configs.train_root, transform=imgaug)
train_loader = data.DataLoader(train_set,
batch_size=configs.Train.batch_size,
shuffle=configs.shuffle,
num_workers=configs.num_workers,
pin_memory=True)
else:
train_set = datasets.ImageFolder(configs.train_root, transform=None)
train_loader = data.Dataloader(train_set,
batch_size=configs.Train.batch_size,
shuffle=configs.shuffle,
num_workers=configs.num_workers,
pin_memory=True)
for epoch in range(configs.Train.nepochs):
if epoch > 0 and epoch // 2 == 0:
adjust_lr(optimizer, configs)
for idx, (img, target) in enumerate(train_loader):
if configs.cuda:
device = torch.device("cuda")
img = img.to(device)
target = target.to(device)
out = model(img)
loss = criterion(out, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print("|Epoch|: {}, {}/{}, loss{}".format(
epoch, idx,
len(train_set) // configs.Train.batch_size, loss.item()))
pth_path = "./weights/{}_{}.pth".format(configs.backbone, epoch)
with open(pth_path, 'wb') as f:
torch.save(model.state_dict(), f)
print("Save weights to ---->{}<-----".format(pth_path))
with open("./weights/final.pth", 'wb') as f:
torch.save(model.state_dict(), f)
print("Final model saved!!!")
features = torch.tensor(np.random.normal(
0, 1, (num_examples, num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size(), dtype=torch.float)
# 读取数据集
batch_size=10
# combine features and labels of dataset
dataset=Data.TensorDataset(features, labels)
# put dataset into Dataloader
data_iter=Data.Dataloader(
dataset=dataset,
batch_size=batch_size,
shuffle=True,
num_workers=2,
)
for X, y in data_iter:
print(X, '\n', y)
break
# 定义模型
class LinearNet(nn.Module):
def __inti__(self, n_feature):
# call father function to init
super(LinearNet, self).__init__()
slef.linear=nn.Linear(n_feature, 1)
def forward(slef, x):
def train_model(image_datasets, arch='vgg19', hidden_units=4096, epochs=20, learning_rate=0.001, gpu=False, checkpoint=''):
if args.arch:
arch=args.arch
if args.hidden_units:
hidden_units=args.hidden_units
if args.epochs:
epochs=args.epochs
if args.learning_rate:
learning_rate=args.learning_rate
if args.gpu:
gpu=args.gpu
if args.checkpoint:
checkpoint=args.checkpoint
dataloaders= {
x: data.Dataloader(image_datasets[x], batch_size=4, shuffle=True, num_workers=2)
for x in list(image_datasets.keys())
}
dataset_sizes={
x: len(dataloaders[x].dataset)
for x in list(image_datasets.keys())
}
num_labels= len(image_datasets['train'].classes)
model= load_model(arch=arch, num_labels=num_labels, hidden_units=hidden_units)
if gpu and torch.cuda.is_available():
print('Using GPU for training')
device = torch.device("cuda:0")
model.cuda()
else:
print('Using CPU for training')
device = torch.device("cpu")
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
scheduler= lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1)
since=time.time()
best_model_weights= copy.deepcopy(model.state_dict())
best_accuracy=0.0
for epoch in range(epochs):
print('Epoch {}/{}'.format(epoch + 1 , epochs))
print('_' * 10)
for phase in ['train','valid']:
if phase == 'train' :
scheduler.step()
model.train()
else:
model.eval()
running_loss= 0.0
running_correct = 0
for inputs, labels in dataloaders[phase]:
inputs= inputs.to(device)
labels= labels.to(device)
optimizer.zero_grad()
with torch.set_grad_enabled(phase == 'train'):
outputs= model(inputs)
_, preds = torch.max(outputs, 1)
loss= criterion(outputs, labels)
if phase == 'train':
loss.backward()
optimizer.stop()
running_loss+=loss.item() * input.size(0)
running_correct += torch.sum(preds == labels.data)
epoch_loss=running_loss / dataset_sizes[phase]
epoch_acc=running_correct.double() / dataset_sizes[phase]
print('{} Loss:{:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
if phase == 'valid' and epoch_acc > best_accuracy:
best_accuracy=epoch_acc
best_model_weights= copy.deepcopy(model.state_dict())
print()
time_elapsed= time.time() - since
print('Training complete in {:0f}m {0f}s'.format(time_elapsed // 60, time_elapsed %60))
print('Best val Acc: {:4f}'.format(nest_acc))
model.load_state_dict(best_model_weights)
model.class_to_idx= image_datasets['train'].class_to_idx
if checkpoint:
print('Saving checkpoint to:', checkpoint)
checkpoint_dict= {
'arch': arch,
'class_to_idx': model.class_to_idx,
'state_dict':model.state_dict(),
'hidden_units':hidden_units
}
torch.save(checkpoint_dict, checkpoint)
return model
import torch.utils.data as Data
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
#hyper parameters
LR = 0.01
BATCH_SIZE = 32
EPOCH = 12
x = torch.unsqueeze(torch.linspace(-1, 1 , 1000),dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))
torch_dataset = Data.TensorDataset(x, y)
loader = Data.Dataloader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)
#default network
class Net(torch.nn.Module)
def __init__(self):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(1, 20)
self.predict = torch.nn.Linear(20, 1)
def forward(self, x):
x = F.relu(self.hidden(x))
x = self.predict(x)
return x
# different nets
net_SGD = Net()
net_Momentum = Net()
net_RMSprop = Net()
def train():
data = Dataloader(TRAINING_DATA, train_len)
print('Dataloader successful!')
logger = SummaryWriter(os.path.join(LOG_DIR,'-summary'))
opt = {
'epochs': 2,
'layers':1,
'batch_size':16,
'input_dim':400,
'hidden_dim':160,
'out_dim':48,
'num_classes':48,
'embed':100,
'lr': 0.01,
}
model = BiLSTMPool(opt['input_dim'], opt['batch_size'], opt['hidden_dim'], device, opt['layers'])
train_loader = Data.DataLoader(
Data.Subset(data, range(train_len-1)),
batch_size=opt['batch_size'],
shuffle=True,
)
print('TRAIN_LOADED')
model.apply(init_weights)
optimizer = optim.Adam(model.parameters(), lr = opt['lr'])
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
model.to(device)
criterion = nn.CrossEntropyLoss(ignore_index=None).to(device)
print('--------------------TRAIN---------------------')
for epoch in range(opt['epochs']):
itr = 0
scheduler.step()
model.train()
running_loss = 0
running_corrects = 0
for inputs,labels, segment_indices in tqdm(train_loader, ascii = True, desc = 'train' + str(epoch+1)):
inputs = Variable(inputs, requires_grad=True).to(device)
labels = Variable(labels).to(device)
segment_indices = Variable(segment_indices).to(device)
optimizer.zero_grad()
preds = model(inputs, segment_indices)
loss = criterion(preds, labels)
loss.backward()
optimizer.step()
#_, predicted = torch.max(outputs.data, 1)
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / train_len
epoch_accur = running_corrects.double() / train_len
logger.add_scalar('train_loss_epoch', epoch_loss, epoch)
logger.add_scalar('train_acc_epoch', epoch_accur, epoch)
itr +=1
#Save model
torch.save(model)
torch.cuda.empty_cache()
logger.close()
print('--------------------TEST----------------------')
data = Dataloader(TEST_DATA, test_len)
test_loader = Data.Dataloader(Data.Subset(data, range(test_len -1)),
batch_size=opt['batch_size'],
shuffle=True,)
accu = []
losses = []
model.eval()
y = {'Actual': [], 'Predicted': []}
with torch.no_grad():
for inputs, labels, segment_indices in tqdm(test_loader, ascii = True, desc = 'Test'):
inputs = Variable(inputs, requires_grad = False).to(device)
output = model(inputs).to(device)
probs = nn.Softmax(dim=1)(output)
preds = torch.max(probs, 1)[1]
losses = criterion(preds, labels)
accuracy.append(accuracy_fn(preds, labels))
losses.append(losses.item())
y['Actual'].extend(labels.tolist())
y['Predicted'].extend(preds.tolist())
torch.cuda.empty_cache()
final_acc = np.mean(accuracy)
final_loss = np.mean(losses)
return final_acc, final_loss, y
reduced_uu_label = 10 * np.ones((len(total_uu), ))
reduced_X_train = np.concatenate([X_train, reduced_uu])
reduced_y_train = np.concatenate([y_train, reduced_uu_label])
reduced_y_train = np.array(reduced_y_train, dtype=np.int64)
pre_rect_trainset = customDataset(X_train, y_train)
finaltrainset = customDataset(rect_X_train, rect_y_train)
reduced_trainset = customDataset(reduced_X_train, reduced_y_train)
IDtest = customDataset(X_test, y_test)
OODtest = customDataset(imagenet_data, imagenet_labels)
Hybridtest = customDataset(new_X_test, new_y_test)
origin_train = data.Dataloader(pre_rect_trainset,
batch_size=256,
shuffle=True,
pin_memory=True)
final_train = data.DataLoader(finaltrainset,
batch_size=256,
shuffle=True,
pin_memory=True)
reduced_train = data.DataLoader(reduced_trainset,
batch_size=256,
shuffle=True,
pin_memory=True)
IDtest_loader = data.DataLoader(IDtest,
batch_size=256,
shuffle=False,
pin_memory=True)
OODtest_loader = data.DataLoader(OODtest,
def train():
# 获取数据
dataset = DogCat('./data/dogcat/', train=True)
train_data = data.Dataloader(dataset,
batch_size=10,
shuffle=True,
num_workers=0)
dataset = DogCat('./data/dogcat/', train=False)
test_data = data.Dataloader(dataset,
batch_size=10,
shuffle=True,
num_workers=0)
# 定义模型
model = getattr(models, 'AlexNet')
if load_model_path:
model.load(load_model_path)
if use_gpu:
model.cuda()
# 定义损失函数以及优化函数
criterion = nn.CrossEntropyLoss()
lr = opt.lr
weight_decay = opt.weight_decay
optimizer = optim.SGD(model.parameters(), lr, weight_decay)
# 定义评估函数
loss_meter = meter.AverageValueMeter()
previous_loss = opt.previous_loss
# 开始训练
epochs = opt.epochs
for epoch in range(epochs):
loss_meter.reset()
# 载入训练数据
for i, (data, label) in enumerate(train_data):
data = Variable(data)
label = Variable(label)
if use_gpu:
data.cuda()
label.cuda()
optimizer.zero_grad()
score = model(data)
loss = criterion(label, score)
loss.backward()
optimizer.step()
# 更新评估函数
loss_meter.add(loss.data[0])
# 可视化模块，略去
if i % 200 == 0:
print('batch{},epoch is {}, loss is {}'.format(
i, epoch, loss_meter))
model.save()
# 计算在验证集上的指标以及可视化
loss = val()
# 可视化略
# 如果损失不再下降，那么将学习率变小
if loss_meter.value[0] > previous_loss:
lr = lr * weight_decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value[0]