def get_dataloader(root_path, subset, transform, batch, workers):
'''
Returns a dataloader object
-----------------------
Args:
- root_path (str)
- subset (str)
"train", "val", "test"
- transform (torch transform obj)
Returns: dataloader object
-----------------------
'''
datafolder = datasets.ImageFolder(
Path.joinpath(root_path, subset),
transform,
)
if subset == "train":
dataloader = Dataloader(datafolder,
batch_size=batch,
shuffle=True,
num_workers=workers)
else:
dataloader = Dataloader(datafolder,
batch_size=batch,
shuffle=False,
num_workers=workers)
return dataloader
def test(**kwargs):
opt._parse(kwargs)
model = eval("models." + opt.model + "_" + opt.feature + "_" +
str(opt.classes) + "class()")
data = eval(opt.feature + "(\"test\")")
test_dataloader = Dataloader(data,
batch_size=1,
shuffle=False,
num_workers=opt.num_workers)
opt.nodes = ''
f1 = open('./confusion_matrix/' + opt.notes + opt.model + "_" +
opt.feature + "_" + str(opt.classes) + "class" +
'_real_label.txt',
mode='w',
encoding='utf-8')
f2 = open('./confusion_matrix/' + opt.notes + opt.model + "_" +
opt.feature + "_" + str(opt.classes) + "class" +
'_pred_label.txt',
mode='w',
encoding='utf-8')
model.load_latest(opt.notes)
model.to(opt.device)
total = 0
cnt = 0
for ii, (data, label) in tqdm(enumerate(test_dataloader)):
if opt.feature == "mel_plus_cqt":
input = [_data.cuda() for _data in data]
else:
input = data.cuda()
target = label.cuda()
score = model(input)
# calculate precision
for i in range(score.shape[0]):
for j in range(opt.duration):
cnt += 1
if torch.argmax(score,
dim=1)[i][j] == torch.argmax(target,
dim=1)[i][j]:
total += 1
f1.write(str(torch.argmax(target, dim=1)[i][j].item()) + '\n')
f2.write(str(torch.argmax(score, dim=1)[i][j].item()) + '\n')
f1.close()
f2.close()
# print("***************************************************total is:",total/(opt.test_len*opt.duration))
print(cnt)
print("***************************************************total is:",
total / cnt)
init_seed(0)
# resnet = Resnet1D_bottleneck(channels=[128, 256, 512, 512], blocks=(1, 1, 1, 1))
resnet = Resnet1D(channels=[128, 256, 512, 512],
blocks=(1, 1, 1, 1),
num_class=9)
model = Model(resnet)
conf = edict()
conf.max_epochs = 1000
conf.use_cuda = True
conf.save_model_name = 'model_new_2.pkl' # weight decay
conf.resume = None
conf.optimizer = optim.Adam(model.parameters(),
lr=0.001,
weight_decay=2e-4)
# conf.optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=2e-4)
conf.lr_scheduler = CosineAnnealingWarmRestarts(conf.optimizer,
T_0=100,
T_mult=1,
eta_min=1e-5) #
# conf.lr_scheduler = StepLR(conf.optimizer, 1, 0.95) # 41-- 0.001
conf.dataloader = Dataloader(Dataset_triple(split='training',
n_triple=1000),
batch_size=512,
shuffle=True)
conf.test_dataloader = Dataloader(Dataset(split='testing', binary=False),
batch_size=4096,
shuffle=False)
# conf.lossf = nn.CrossEntropyLoss(weight=torch.tensor([1]+[0.05]*8).cuda())
conf.lossf = nn.CrossEntropyLoss()
best_model = model.train_model(conf)
print('--- val ---')
val_metric = self.eval_model(eval_loader, verbose=True)
print('==' * 10)
return best_model
if __name__ == "__main__":
init_seed(0)
resnet = Resnet1D(channels=[64, 128, 256], blocks=(1, 1, 1))
model = Model(resnet)
conf = edict()
conf.max_epochs = 200
conf.use_cuda = True
conf.save_model_name = 'model_st.pkl'
conf.resume = None
conf.optimizer = optim.Adam(model.parameters(),
lr=0.001,
weight_decay=2e-4)
# conf.lr_scheduler = CosineAnnealingWarmRestarts(conf.optimizer, T_0=25, T_mult=1, eta_min=1e-5) # model_dr0.5
conf.lr_scheduler = StepLR(conf.optimizer, 25, 0.5) # model_st
conf.dataloader = Dataloader(Dataset(split='training', oversample=False),
batch_size=512,
shuffle=True)
conf.test_dataloader = Dataloader(Dataset(split='testing'),
batch_size=4096,
shuffle=False)
conf.lossf = nn.CrossEntropyLoss()
best_model = model.train_model(conf)
def main():
global args
parser = build_parser()
args = parser.parse_args()
rank = dist.get_rank()
set_seed(args.seed + rank)
#use_cuda = not args.no_cuda and torch.cuda.is_available()
######### set distributed args for multi-gpus ############
local_rank = args.local_rank
dist.init_process_group(
'nccl',
init_method='tcp://localhost:9118',
rank=local_rank,
world_size=args.gpus,
)
torch.cuda.set_device(local_rank)
cur_device = torch.cuda.current_device()
#train_kwargs = {'batch_size': args.batch_size}
#test_kwargs = {'batch_size': args.test_batch_size}
#if use_cuda:
#cuda_kwargs = {'num_workers': 1,
# 'pin_memory': True,
# 'shuffle': True}
# train_kwargs.update(cuda_kwargs)
# test_kwargs.update(cuda_kwargs)
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
dataset1 = datasets.MNIST('../data',
train=True,
download=True,
transform=transform)
dataset2 = datasets.MNIST('../data', train=False, transform=transform)
#train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
#test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
def construct_sampler(dataset, shuffle):
sampler = torch.utils.data.distributed.DistributedSampler(dataset, shuffle=shuffle) \
if args.gpus > 1 else None
return sampler
train_loader = Dataloader(dataset1, batch_size=args.batch_size//max(args.gpus,1), \
shuffle=False, sampler=construct_sampler(dataset1, shuffle=True), num_workers=4, \
pin_memory=True, drop_last=True)
test_loader = Dataloader(dataset2, batch_size=args.test_batch_size//max(args.gpus,1), \
shuffle=False, sampler=construct_sampler(dataset2, shuffle=False), num_workers=4, pin_memory=True)
if dist.get_rank() == 0:
print ("Total train examples: {} total test examples: {} \n".\
format(len(train_loader.dataset), len(test_loader.dataset)))
print("Building model......\n")
#model = Net().to(device)
model = Net().cuda(device=cur_device)
model = DDP(model, device_ids=[cur_device], output_device=cur_device)
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
for epoch in range(1, args.epochs + 1):
if dist.get_rank() == 0:
print("Training epoch ", epoch)
train(args, model, cur_device, train_loader, optimizer, epoch)
test(model, cur_device, test_loader)
scheduler.step()
if args.save_model:
torch.save(model.module.state_dict(), "mnist_cnn.pt")
def train(**kwargs):
# parse args, load network, set class number as 4/7
opt._parse(kwargs)
model = eval("models." + opt.model + "_" + opt.feature + "_" +
str(opt.classes) + "class()")
print(model.get_model_name())
if opt.load_latest is True:
model.load_latest(opt.notes)
elif opt.load_model_path:
print("load_model:", opt.load_model_path)
model.load(opt.load_model_path)
model.to(opt.device)
model.save(opt.notes)
print("Loading data..")
# load data
data = eval(opt.feature + "(\"train\")")
lengths = [opt.train_len, opt.eval_len]
# if opt.dataset == "zhudi":
# other_len = 1021
# lengths = [opt.train_len, opt.eval_len]
# lengths = [int(0.75*(opt.total_len+other_len)), opt.total_len+other_len-int(0.75*(opt.total_len+other_len))]
train_mel_dataset, test_mel_dataset = torch.utils.data.dataset.random_split(
data, lengths)
train_dataloader = Dataloader(train_mel_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
test_dataloader = Dataloader(test_mel_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# set loss and learning parameters
criterion = torch.nn.BCELoss()
lr = opt.lr
optimizer = torch.optim.Adam(model.parameters(),
lr=lr,
weight_decay=opt.weight_decay)
loss_meter = torchnet.meter.AverageValueMeter()
previous_loss = 1e100
eva_result = eva_test(test_dataloader, model, criterion)
# begin train
print("Begin train..")
for epoch in range(opt.max_epoch):
print("this is ", epoch, "epoch")
loss_meter.reset()
loss_sum = 0.0
count = 0.0
for ii, (data, label) in tqdm(enumerate(train_dataloader)):
if opt.feature == "mel_plus_cqt":
input = [_data.cuda() for _data in data]
else:
input = data.cuda()
target = label.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
loss_sum += loss.item()
count += 1
optimizer.step()
loss_meter.add(loss.item())
eva_result = eva_test(test_dataloader, model, criterion)
print("train_loss:", loss_meter.value()[0], " ", loss_sum / count)
if epoch % opt.print_freq == opt.print_freq - 1:
print("train_loss:", loss_meter.value()[0], " ", loss_sum / count)
model.save(opt.notes)
discriminator=discriminator.to(device)
features=features.to(device)
criterion_Gan=criterion_Gan.to(device)
criterion_percept=criterion_percept.to(device)
#set optimizers (Adam)
optimizer_G=torch.optim.Adam(generator.parameters(),lr=0.001,betas=(0.5,0.99))
optimizer_D=torch.optim.Adam(generator.parameters(),lr=0.001,betas=(0.5,0.99))
Tensor=torch.cuda.FloatTensor if device=="gpu" else torch.Tensor
#create the dataloader
dataloader=Dataloader(ImagesDataset("data/HRimages",(125,125)),
batch_size=3,
shuffle=True)
#featur extractor using the pretrained vgg
def extractor(real,fake):
f_HR=features(real)
f_LR=features(fake)
return f_HR,f_LR
print("start training")
for epoch in range(opt.epochs):
print("epoch :",epoch)
for i,img in enumerat(dataloader):
#get the hr and lr images
img_lr=Variable(img["lr"].type(Tensor))
from sklearn.manifold import TSNE
from utils import Dataset, evaluation_metrics
import matplotlib.pyplot as plt
from main import Model
import torch
import pickle
import numpy as np
import os
from sklearn.metrics import confusion_matrix
use_cuda = True
with open('./exp/model_True_4_0', 'rb') as fp:
model = pickle.load(fp)
loader = Dataloader(Dataset(split='testing', oversample=False),
batch_size=4096)
FloatTensor = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor
model.eval()
y_truth = []
y_pred = []
fea_list = []
for i, (X, y) in enumerate(loader):
X = X.type(FloatTensor)
with torch.no_grad():
pred, fea = model(X)
y_pred.append(pred.cpu().numpy().argmax(axis=-1))
y_truth.append(y.numpy())
fea_list.append(fea.cpu().numpy())
def __init__(self, csv_file, txt_file, root_dir, other_file):
self.csv_data = pd.read_csv(csv_file)
with open(txt_file, 'r') as f:
data_list = f.readlines()
self.txt_data = data_list
self.root_dir = root_dir
def __len__(self):
return len(self.csv_data)
def __getitem__(self, idx):
data = (self.csv_data[idx], self.txt_data[idx])
return data
dataiter = Dataloader(myDataset, batch_size=32, shuffle=True)
#%% module
from torch import nn, from_numpy
from torch.autograd import Variable
class net(nn.Module):
def __init__(self, other_args):
super(net, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)
# other network layers
def forward(self, x):
x = self.conv1(x)
return x
cudnn.benchmark = True
device = torch.device("cuda")
#Dataset Processing
transform = tf.Compose([
tf.Resize(256), #Default image_size
tf.ToTensor(), #Transform it to a torch tensor
tf.CenterCrop(256),
#tf.Lambda(lambda x:x[torch.LongTensor([2, 1,0])]), #Converting from RGB to BGR
#tf.Normalize(mean=[0.40760392, 0.45795686, 0.48501961], std=[0.225, 0.224, 0.229]), #subracting imagenet mean
tf.Lambda(lambda x: x.mul_(255))
])
data = "./data/"
train_dataset = datas.ImageFolder(data, transform)
train_loader = Dataloader(train_dataset, batch_size=4)
transformer = TransformerNet().to(device)
optimizer = Adam(transformer.parameters(), 1e-3)
mse_loss = nn.MSELoss()
vgg_directory = "./vgg_conv.pth" #path to pretrained vgg vgg_directory
vgg = VGG()
vgg.load_state_dict(torch.load(vgg_directory))
for param in vgg.parameters():
param.requires_grad = False
vgg.to(device) # Putting model on cuda
def load_img(path):
img = Image.open(path)
train_set = torchvision.datasets.FashionMNIST(
root='./data/FashionMNIST',
train=True,
#download=True,
transform=transforms.Compose([
transforms.ToTensor()
])
)
#/---------------------Training with a single batch-----------------/
#Step1: Initialize a network.
network = Network()
network = network
#Step2: General setup: Load data. Setup optimizer. Initialize total loss and correct.
train_loader = Dataloader(train_set, batch_size=100)
optimizer = optim.Adam(network.parameters(), lr=0.01) #lr: learning rate.
batch_num = 0
#Step3: Get batch from the train_loader
#batch = next(iter(train_loader)) #Train with single batch.
for epoch in range(5):
total_loss = 0
total_correct = 0
for batch in train_loader:
batch_num += 1
images, labels = batch
images = images