def main(args):
train_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset("UrbanSound8K_train.pkl", mode),
batch_size=args.batch_size, shuffle=True,
num_workers=args.worker_count, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset("UrbanSound8K_test.pkl", mode),
batch_size=args.batch_size, shuffle=False,
num_workers=args.worker_count, pin_memory=True)
# Cross entropy loss as declared
criterion = nn.CrossEntropyLoss()
# Using SGD with momentum as declared
# Torch implemenation of optim.SGD includes L2 Reg as base
optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum)
# Get mode from args, LMC, MC, or MLMC expected
mode = args.mode
if(mode == 'LMC'):
model = CNN(height=85, width=41, channels=3, class_count=10, dropout=args.dropout)
elif(mode == 'MC'):
model = CNN(height=85, width=41, channels=3, class_count=10, dropout=args.dropout)
# TODO Need to add support for MLMC combined since sizes are increased
optimizer = optim.SGD(model.parameters(), lr=args.learning_rate)
model = model.to(DEVICE)
# Run training for all epochs, validation as expected
for epoch in range(0,args.epochs):
print("Epoch : " + str(epoch+1))
trainer(train_loader, model, criterion, args.val_frequency, DEVICE)
if(epoch+1 % val_frequency == 0):
validate(val_loader, model, criterion, DEVICE)
def main(args):
train_dataset=UrbanSound8KDataset('UrbanSound8K_train.pkl', "MC")
training_class_counts=np.array([6295, 1825, 6248, 5121, 5682, 6282, 1112, 5886, 5819, 6299])
class_weights=1/training_class_counts
data_weights=[]
for i in range(0,len(train_dataset)):
features, label, filename, labelname=train_dataset.__getitem__(i)
data_weight=class_weights[label]
data_weights.append(data_weight)
sampler = torch.utils.data.sampler.WeightedRandomSampler(torch.tensor(data_weights), len(train_dataset))
train_loader = torch.utils.data.DataLoader(
train_dataset,
shuffle=False,
batch_size=args.batch_size,
pin_memory=True,
num_workers=args.worker_count,
sampler=sampler,
)
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', "MC"),
shuffle=False,
batch_size=args.batch_size,
num_workers=args.worker_count,
pin_memory=True,
)
model = MCNet(height=85, width=41, channels=1, class_count=10,dropout=args.dropout)
## TASK 8: Redefine the criterion to be softmax cross entropy
criterion = nn.CrossEntropyLoss()
## TASK 11: Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, betas=(0.9, 0.999), weight_decay=0.004)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(
str(log_dir),
flush_secs=5
)
trainer = Trainer(
model, train_loader, test_loader, criterion, optimizer, summary_writer, DEVICE
)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary(model, input_size=(1, 85, 41))
summary_writer.close()
def validate_model(args):
if torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
criterion = CrossEntropyLoss()
mode = args.mode
if mode in ['MC','LMC','MLMC']:
validation_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', mode),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.worker_count,
pin_memory=True
)
model = CNN(height=85, width=41, channels=1, class_count=10, dropout=0.5, mode = mode)
checkpoint = torch.load(args.checkpoint, map_location = device)
model.load_state_dict(checkpoint['model'])
print(f"Validating {mode} model with parameters trained for {checkpoint['epoch']} epochs.")
loss, accuracy, class_accuracies = validate_single(model, validation_loader, criterion, device)
print(f"accuracy: {accuracy * 100:2.2f}")
print_class_accuracies(class_accuracies)
elif mode == 'TSCNN':
loader_LMC = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', 'LMC'),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.worker_count,
pin_memory=True
)
loader_MC = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', 'MC'),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.worker_count,
pin_memory=True
)
model1 = CNN(height=85, width=41, channels=1, class_count=10, dropout=0.5, mode = 'LMC')
model2 = CNN(height=85, width=41, channels=1, class_count=10, dropout=0.5, mode = 'MC')
checkpoint1 = torch.load(args.checkpoint, map_location = device)
model1.load_state_dict(checkpoint1['model'])
checkpoint2 = torch.load(args.checkpoint2, map_location = device)
model2.load_state_dict(checkpoint2['model'])
print(f"Validating {mode} model with parameters trained for {checkpoint1['epoch']} and {checkpoint2['epoch']} epochs.")
accuracy, class_accuracies = validate_double(model1, model2, loader_LMC, loader_MC, criterion, device)
print(f"accuracy: {accuracy * 100:2.2f}")
print_class_accuracies(class_accuracies)
else:
print('Please provide a valid argument.')
def main(args):
transform = ToTensor()
train_data = UrbanSound8KDataset('UrbanSound8K_train.pkl', args.mode)
val_data = UrbanSound8KDataset('UrbanSound8K_test.pkl', args.mode)
train_loader = torch.utils.data.DataLoader(
train_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True,
)
val_loader = torch.utils.data.DataLoader(
val_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True,
)
model = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=args.mode)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.decay)
#optimizer = optim.AdamW(model.parameters(), lr=args.learning_rate, betas=(0.9, 0.999), eps=1e-08, weight_decay=args.decay, amsgrad=False)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(str(log_dir), flush_secs=5)
trainer = Trainer(model, train_loader, val_loader, criterion, optimizer,
summary_writer, DEVICE, args.mode)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
def main(args):
transform = transforms.ToTensor()
mode = args.mode
train_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_train.pkl', mode),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.worker_count,
pin_memory=True
)
val_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', mode),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.worker_count,
pin_memory=True
)
## Build a model based on mode
if args.mode == 'MLMC':
model = CNN(height=145, width=41, channels=1, class_count=10, dropout=args.dropout,mode = args.mode)
else:
model = CNN(height=85, width=41, channels=1, class_count=10, dropout=args.dropout,mode = args.mode)
## Redefine the criterion to be softmax cross entropy
criterion = nn.CrossEntropyLoss()
## Use adam optimizer. AdamW is Adam with L-2 regularisation.
optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(
str(log_dir),
flush_secs=5
)
trainer = Trainer(
model, train_loader, val_loader, criterion, optimizer, summary_writer,
DEVICE, args.checkpoint_path, checkpoint_frequency = args.checkpoint_frequency
)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
def run(mode):
if torch.cuda.is_available():
DEVICE = torch.device("cuda")
else:
DEVICE = torch.device("cpu")
mode = mode
train_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_train.pkl', mode),
batch_size=32,
shuffle=True,
num_workers=8,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_test.pkl', mode),
batch_size=32,
shuffle=False,
num_workers=8,
pin_memory=True)
isMLMC = False
if (mode == 'MLMC'):
isMLMC = True
model = CNN(height=41,
width=85,
channels=1,
class_count=10,
dropout=0.5,
isMLMC=isMLMC)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=0.001,
weight_decay=1e-6)
trainer = Trainer(model, train_loader, val_loader, criterion, optimizer,
DEVICE)
int_results = trainer.train(
epochs=50,
print_frequency=50,
val_frequency=5,
)
return int_results
def main():
global args, best_prec1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if args.mode != 'LMC+MC':
print(args.mode)
model = ESCModel(mode=args.mode)
model = torch.nn.DataParallel(model, device_ids=None).to(device)
train_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
args.train_pickle, args.mode),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
args.test_pickle, args.mode),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
scheduler = MultiStepLR(optimizer, args.lr_steps, gamma=0.1)
for epoch in range(args.epochs):
scheduler.step()
train(train_loader, model, criterion, optimizer, epoch, device)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion, device)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best)
summaryWriter.close()
def main(args):
transform = transforms.ToTensor()
args.dataset_root.mkdir(parents=True, exist_ok=True)
train_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_train.pkl', mode=args.mode),
batch_size=32, shuffle=True,
num_workers=8, pin_memory=True)
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', mode=args.mode),
batch_size=32, shuffle=False,
num_workers=8, pin_memory=True)
# Change the input dimensions if we are using MLMC.
# Direct user to correct file if they want to use TSCNN.
if args.mode == "LMC" or args.mode == "MC":
model = CNN(height=85, width=41, channels=1, class_count=10, dropout=args.dropout, mode=args.mode)
elif args.mode == "MLMC":
model = CNN(height=145, width=41, channels=1, class_count=10, dropout=args.dropout, mode=args.mode)
elif args.mode == "TSCNN":
print("Use file late_fusion.py to run TSCNN with trained LMCNet and MCNet")
criterion = nn.CrossEntropyLoss()
# Paper specifies "variant of stochastic gradient descent" with reference
# pointing to Adam. Weight decay used for L2 regularisation.
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(
str(log_dir),
flush_secs=5
)
trainer = Trainer(
model, train_loader, test_loader, criterion, optimizer, summary_writer,
DEVICE, args.checkpoint_path, args.checkpoint_frequency
)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
def abstractedDataLoader(dataset, datatype):
loader = torch.utils.data.DataLoader(
UrbanSound8KDataset(dataset, datatype),
batch_size=32, shuffle=True,
num_workers=8, pin_memory=True
)
return loader
def main(args):
args.dataset_root.mkdir(parents=True, exist_ok=True)
train_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_train.pkl', args.audiotype),
batch_size=32,
shuffle=True,
num_workers=8,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_test.pkl', args.audiotype),
batch_size=32,
shuffle=False,
num_workers=8,
pin_memory=True)
model = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),
lr=args.learning_rate,
weight_decay=5e-3,
betas=(0.9, 0.9))
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(str(log_dir), flush_secs=5)
trainer = Trainer(model, train_loader, val_loader, criterion, optimizer,
summary_writer, DEVICE)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
def build_dataloader(args):
""" Build a training and test dataloader for the UrbanSound8K dataset
Args:
args: the CLI args
Returns:
A tuple of training loader, testing loader and individual inverted class weights
"""
# Load data set and compute class weightings
train_dataset = UrbanSound8KDataset(
args.dataset_root / 'UrbanSound8K_train.pkl',
args.mode,
augmentation_length=args.augmentation_length)
class_weights, sample_weights = calculate_weights(train_dataset)
# Define a weighted sampler for the dataset
weighted_sampler = torch.utils.data.WeightedRandomSampler(
sample_weights, len(train_dataset))
# Configure data loaders for testing and training
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
num_workers=args.worker_count,
sampler=weighted_sampler,
)
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset(args.dataset_root / 'UrbanSound8K_test.pkl',
args.mode),
shuffle=False,
batch_size=args.batch_size,
num_workers=args.worker_count,
pin_memory=True,
)
return train_loader, test_loader, class_weights
def main(args):
criterion = nn.CrossEntropyLoss()
if args.mode in ["LMC", "MC", "MLMC"]:
test_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_test.pkl', mode=args.mode),
batch_size=32,
shuffle=False,
num_workers=8,
pin_memory=True)
if args.mode in ["LMC", "MC"]:
model = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=0.5,
mode=args.mode)
else:
model = CNN(height=145,
width=41,
channels=1,
class_count=10,
dropout=0.5,
mode=args.mode)
checkpoint = torch.load("checkpoint" + args.mode + ".pkl",
map_location=DEVICE)
model.load_state_dict(checkpoint["model"])
validator = Validator(model, test_loader, criterion, DEVICE)
validator.validate(args.mode)
elif args.mode == "TSCNN":
if os.path.isfile("LMCscores.pkl") and os.path.isfile("MCscores.pkl"):
LMCscores = pickle.load(open("LMCscores.pkl", 'rb'))
MCscores = pickle.load(open("MCscores.pkl", 'rb'))
TSCNN(LMCscores, MCscores, DEVICE)
else:
print(
"Run both LMCNet and MCNet to obtain scores before running TSCNN"
)
else:
print("Input one of LMC, MC, MLMC, or TSCNN as the mode argument")
def fetch_loader(
train: bool,
mode: str,
spec_augment: float,
freq_mask=20, # shape of logmelspec
time_mask=5,
):
"""
train: is loader train True/False (else test)
mode: what data type to load
spec_augment: augment data or not
"""
if train:
path = 'UrbanSound8K_train.pkl'
else:
path = 'UrbanSound8K_test.pkl'
loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
path, mode, spec_augment, freq_mask, time_mask),
batch_size=32,
shuffle=train,
num_workers=8,
pin_memory=True)
return loader
def main(args):
mode = args.mode
transform = torchvision.transforms.ColorJitter(
brightness=args.data_aug_brightness)
train_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
"UrbanSound8K_train.pkl", mode),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.worker_count,
pin_memory=True)
if (mode != 'TSCNN'):
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset("UrbanSound8K_test.pkl", mode),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.worker_count,
pin_memory=True)
else:
test_loaderLMC = torch.utils.data.DataLoader(
UrbanSound8KDataset("UrbanSound8K_test.pkl", 'LMC'),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.worker_count,
pin_memory=True)
test_loaderMC = torch.utils.data.DataLoader(
UrbanSound8KDataset("UrbanSound8K_test.pkl", 'MC'),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.worker_count,
pin_memory=True)
criterion = nn.CrossEntropyLoss()
if (mode == 'LMC'):
model = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=1)
elif (mode == 'MC'):
model = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=2)
elif (mode == 'MLMC'):
model = CNN(height=145,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=3)
elif (mode == 'TSCNN'):
modelLMC = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=1)
modelMC = CNN(height=85,
width=41,
channels=1,
class_count=10,
dropout=args.dropout,
mode=2)
# Load state from files
modelLMC.load_state_dict(torch.load("LMC.pth"))
modelMC.load_state_dict(torch.load("MC.pth"))
# Set up arbitrary optimizer to init trainers
optimizer = optim.SGD(modelLMC.parameters(),
lr=args.learning_rate,
momentum=0.9,
weight_decay=0.0001)
if (mode != 'TSCNN'):
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=0.9,
weight_decay=0.0001)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(str(log_dir), flush_secs=5)
if mode == 'TSCNN':
trainerLMC = Trainer(modelLMC, train_loader, test_loaderLMC, criterion,
optimizer, summary_writer, DEVICE, args)
trainerMC = Trainer(modelMC, train_loader, test_loaderMC, criterion,
optimizer, summary_writer, DEVICE, args)
new_tscnn(trainerLMC, trainerMC)
summary_writer.close()
exit()
else:
trainer = Trainer(model, train_loader, test_loader, criterion,
optimizer, summary_writer, DEVICE, args)
print("EPOCHS")
print(args.epochs)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
from torch.nn import functional as F
from torch.optim.optimizer import Optimizer
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import matplotlib.pyplot as plt
from dataset import UrbanSound8KDataset
summary_writer = SummaryWriter('logs', flush_secs=5)
print("cuda is available: ", torch.cuda.is_available())
device = torch.device('cuda' if torch.cuda.is_available() else "cpu")
#region data
train_loader_LMC = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_train.pkl', 'LMC'),
batch_size=32,
shuffle=True,
num_workers=8,
pin_memory=True)
test_loader_LMC = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_test.pkl', 'LMC'),
batch_size=32,
shuffle=False,
num_workers=8,
pin_memory=True)
train_loader_MC = torch.utils.data.DataLoader(UrbanSound8KDataset(
'UrbanSound8K_train.pkl', 'MC'),
batch_size=32,
def main():
parser = argparse.ArgumentParser(description="ESC Fusion model testing")
parser.add_argument('mode', choices=['LMC', 'MC', 'MLMC', 'LMC+MC'])
parser.add_argument('--weights_dir', type=str)
parser.add_argument('--scores_input', nargs='+', type=Path)
parser.add_argument('--scores_output', type=Path)
parser.add_argument('--test_pickle')
parser.add_argument('--mapping')
parser.add_argument('--max_num', type=int, default=-1)
parser.add_argument('--average', action='store_true')
parser.add_argument('-j',
'--workers',
default=4,
type=int,
metavar='N',
help='number of data loading workers (default: 4)')
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if args.mode != 'LMC+MC':
print(args.mode)
net = ESCModel(mode=args.mode)
weights = '{weights_dir}/model_best.pth.tar'.format(
weights_dir=args.weights_dir)
checkpoint = torch.load(weights)
print("model epoch {} best prec@1: {}".format(
checkpoint['epoch'], checkpoint['best_prec1']))
base_dict = {
'.'.join(k.split('.')[1:]): v
for k, v in list(checkpoint['state_dict'].items())
}
net.load_state_dict(base_dict)
test_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
args.test_pickle, args.mode),
batch_size=1,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
net = torch.nn.DataParallel(net, device_ids=None).to(device)
with torch.no_grad():
net.eval()
results = []
total_num = len(test_loader.dataset)
proc_start_time = time.time()
max_num = args.max_num if args.max_num > 0 else total_num
for i, (data, label, fname) in enumerate(test_loader):
if i >= max_num:
break
data = data.to(device)
rst = net(data)
rst = rst.cpu().numpy().squeeze()
label_ = label.item()
results.append((rst, label_, fname))
cnt_time = time.time() - proc_start_time
print(
'video {} done, total {}/{}, average {} sec/video'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
if not args.scores_output.parent.exists():
args.scores_output.parent.mkdir(parents=True)
pickle.dump(results, open(args.scores_output, 'wb'))
scores = np.array([res[0] for res in results])
labels = np.array([res[1] for res in results])
fname = np.array([res[2] for res in results])
print_accuracy(scores,
labels,
fname,
pickle.load(open(args.mapping, 'rb')),
average_segments=args.average)
else:
lmc_results = pickle.load(open(args.scores_input[0], 'rb'))
mc_results = pickle.load(open(args.scores_input[1], 'rb'))
lmc_scores = np.array([res[0] for res in lmc_results])
mc_scores = np.array([res[0] for res in mc_results])
scores = np.array([lmc_scores, mc_scores])
labels = np.array([res[1] for res in lmc_results])
fname = np.array([res[2] for res in lmc_results])
print_accuracy(scores,
labels,
fname,
pickle.load(open(args.mapping, 'rb')),
average_segments=args.average,
fuse=True)
MLMC_test_accuracy = []
MC_train_loss = []
MC_test_loss = []
MC_train_accuracy = []
MC_test_accuracy = []
summary_writer = SummaryWriter('logs',flush_secs=5)
print("cuda is available: ", torch.cuda.is_available())
device = torch.device('cuda' if torch.cuda.is_available() else "cpu")
#region data
train_loader_LMC = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_train.pkl', 'LMC'),
batch_size=32, shuffle=True,
num_workers=8, pin_memory=True)
#train_loader_LMC.input.to(device)
test_loader_LMC = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', 'LMC'),
batch_size=32, shuffle=False,
num_workers=8, pin_memory=True)
#
# from PIL import Image
# for i,(input,target,filenames) in enumerate(train_loader_LMC):
# input2d = np.squeeze(input[i], axis=0)
# plt.imshow(input2d.numpy())
