def test_create_subset(self):
data_path = os.path.join('result_test', 'network1')
test_dataset = dataset.DataSet(data_path)
test_dataset.create_subset('train', frame_len=44100)
test_dataset.create_subset('val')
test_dataset.create_subset('test')
test_dataset.load_file('KDonnerFlangerra12c12rg9Singles1',
['train', 'val', 'test'], [0.75, 0.125, 0.125])
test_dataset.load_file('KDonnerFlangerra12c12rg9Singles1')
test_dataset2 = dataset.DataSet(data_path, extensions=None)
test_dataset2.create_subset('train', frame_len=44100)
test_dataset2.create_subset('val')
test_dataset2.create_subset('test')
test_dataset2.load_file('KDonnerFlangerra12c12rg9Singles1-input')
test_dataset2.load_file('KDonnerFlangerra12c12rg9Singles1-input',
['train', 'val', 'test'], [0.75, 0.125, 0.125])
test_dataset2.load_file('KDonnerFlangerra12c12rg9Singles1-input',
['train', 'val', 'test'], [0.75, 0.125, 0.125])
test_dataset3 = dataset.DataSet(data_path, extensions=None)
test_dataset3.create_subset('train', frame_len=44100)
test_dataset3.create_subset('val')
test_dataset3.create_subset('test')
test_dataset3.load_file('KDonnerFlangerra12c12rg9Singles1-input',
cond_val=0)
test_dataset3.load_file('KDonnerFlangerra12c12rg9Singles1-input',
['train', 'val', 'test'], [0.75, 0.125, 0.125],
cond_val=0.25)
test_dataset3.load_file('KDonnerFlangerra12c12rg9Singles1-input',
cond_val=0.5)
def proc_audio(args):
network_data = miscfuncs.json_load(args.model_file)
network = networks.load_model(network_data)
data = dataset.DataSet(data_dir='', extensions='')
data.create_subset('data')
data.load_file(args.input_file, set_names='data')
with torch.no_grad():
output = network(data.subsets['data'].data['data'][0])
write(args.output_file, data.subsets['data'].fs,
output.cpu().numpy()[:, 0, 0])
def test_system():
network = networks.RecNet()
network.add_layer({'block_type': 'GRU', 'input_size': 2, 'output_size': 1, 'hidden_size': 16})
data = dataset.DataSet(os.path.join('result_test', 'network1'))
data.create_subset('train', 8820)
data.load_file('KDonnerFlangerra12c12rg9Singles1', set_names='train')
optimiser = torch.optim.Adam(network.parameters(), lr=0.0001)
loss_fcn = training.ESRLoss()
batch_size = 10
init_len = 120
up_fr = 100
for i in range(3):
print('Starting epoch ' + str(i+1))
train_losses = []
# shuffle the segments at the start of the epoch
train_input = data.subsets['train'].data['input'][0]
train_target = data.subsets['train'].data['target'][0]
shuffle = torch.randperm(train_input.shape[1])
for n in range(math.ceil(shuffle.shape[0]/batch_size)):
# Load batch of randomly selected segments
batch_losses = []
batch = train_input[:, shuffle[n*batch_size:(n+1)*batch_size], :]
target = train_target[:, shuffle[n*batch_size:(n+1)*batch_size], :]
# Run initialisation samples through the network
network(batch[0:init_len, :, :])
# Zero the gradient buffers
network.zero_grad()
# Iterate over the remaining samples in the sequence batch
for k in range(math.ceil((batch.shape[0]-init_len)/up_fr)):
output = network(batch[init_len+(k*up_fr):init_len+((k+1)*up_fr), :, :])
# Calculate loss
loss = loss_fcn(output, target[init_len+(k*up_fr):init_len+((k+1)*up_fr), :, :])
train_losses.append(loss.item())
batch_losses.append(loss.item())
loss.backward()
optimiser.step()
# Set the network hidden state, to detach it from the computation graph
network.detach_hidden()
print('batch ' + str(n+1) + ' loss = ' + str(np.mean(batch_losses)))
print('epoch ' + str(i+1) + ' loss = ' + str(np.mean(train_losses)))
def test_network_loading(self):
network_params = miscfuncs.json_load('config.json',
['result_test', 'network1'])
network_params['state_dict'] = torch.load(
os.path.join('result_test', 'network1', 'modelBest.pt'),
map_location=torch.device('cpu'))
model_data = networks.legacy_load(network_params)
network = networks.load_model(model_data)
data = dataset.DataSet(os.path.join('result_test', 'network1'))
data.create_subset('test', 0)
data.load_file('KDonnerFlangerra12c12rg9Singles1', set_names='test')
with open(os.path.join('result_test', 'network1', 'tloss.txt')) as fp:
x = fp.read()
with torch.no_grad():
output = network(data.subsets['test'].data['input'][0])
loss_fcn = training.ESRLoss()
loss = loss_fcn(output, data.subsets['test'].data['target'][0])
assert abs(loss.item() - float(x[1:-1])) < 1e-5
else:
save_path = 'Results/' + args.device + '_hs-' + str(args.hidden_size) + \
'_nl-' + str(args.num_layers) + '_' + args.file_name
# Check if a cuda device is available
if not torch.cuda.is_available():
print('cuda device not available')
cuda = 0
else:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.set_device(0)
print('cuda device available')
cuda = 1
# Create dataset object
dataset = dataset.DataSet(data_dir=args.data_location)
dataset.create_subset('train', frame_len=args.seg_len)
dataset.create_subset('val')
dataset.create_subset('test')
#dataset = dataset.DataSet('data')
#dataset.load_file('train/BehPhaserToneoffSingles1', 'train')
#dataset.load_file('val/BehPhaserToneoffSingles1', 'val')
#dataset.load_file('test/BehPhaserToneoffSingles1', 'test')
dataset.load_file(args.file_name, ['train', 'val', 'test'],
[0.75, 0.125, 0.125])
# Create instance of Network.RNN class
network = networks.SimpleRNN(hidden_size=args.hidden_size,
num_layers=args.num_layers,
# Set up training optimiser + scheduler + loss fcns and training info tracker
optimiser = torch.optim.Adam(network.parameters(),
lr=args.learn_rate,
weight_decay=1e-4)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimiser,
'min',
factor=0.5,
patience=5,
verbose=True)
loss_functions = training.LossWrapper(args.loss_fcns, args.pre_filt)
train_track = training.TrainTrack()
writer = SummaryWriter(os.path.join('runs2', model_name))
# Load dataset
dataset = dataset.DataSet(data_dir='Data')
dataset.create_subset('train', frame_len=22050)
dataset.load_file(os.path.join('train', args.file_name), 'train')
dataset.create_subset('val')
dataset.load_file(os.path.join('val', args.file_name), 'val')
dataset.create_subset('test')
dataset.load_file(os.path.join('test', args.file_name), 'test')
# If training is restarting, this will ensure the previously elapsed training time is added to the total
init_time = time.time() - start_time + train_track['total_time'] * 3600
# Set network save_state flag to true, so when the save_model method is called the network weights are saved
network.save_state = True
patience_counter = 0