def captioning(image_path):
loader = data_loader(
features_shape=2048,
attention_features_shape=64,
batch_size=256,
buffer_size=1000,
top_k=5000
)
## loadm odel and checkpoint
embedding_matrix = np.load("./content/drive/My Drive/datasets/embeddingmatrix.npy")
encoder = Encoder(200)
decoder = Decoder(embedding_dim=200, vocab_size=loader.top_k + 1, units=512, embedding_matrix = embedding_matrix)
optimizer = tf.keras.optimizers.Adam()
checkpoint_path = "./content/drive/My Drive/datasets/modelcheckpoint/embedding"
ckpt = tf.train.Checkpoint(encoder=encoder, decoder=decoder, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=3)
if ckpt_manager.latest_checkpoint:
ckpt.restore(ckpt_manager.latest_checkpoint)
## inference time
result, _ = evaluate(
encoder,
decoder,
loader.tokenizer,
loader.max_length,
loader.attention_features_shape,
image_path
)
result = " ".join(result)
return result
def test(args):
## Load data & Create batch
clean_data, noisy_data = dt.data_loader(test=True, need_length=True)
# Batch
# - Proccessing speech interval can be adjusted by "start_frame" and "start_frame".
# - "None" -> All speech in test dataset.
baches_test = dt.create_batch_test(clean_data, noisy_data, start_frame=None, stop_frame=None)
del clean_data, noisy_data
## Create network
# Variables
noisy_t = nn.Variable(baches_test.noisy.shape) # Input
z = nn.Variable([baches_test.noisy.shape[0], 1024, 8]) # Random Latent Variable
# Network (Only Generator)
output_t = Generator(noisy_t, z)
## Load parameter
# load generator
with nn.parameter_scope("gen"):
print(args.epoch)
nn.load_parameters(os.path.join(args.model_save_path, "generator_param_{:04}.h5".format(args.epoch)))
## Validation
noisy_t.d = baches_test.noisy
#z.d = np.random.randn(*z.shape)
z.d = np.zeros(z.shape) # zero latent valiables
output_t.forward()
## Create wav files
dt.wav_write('clean.wav', baches_test.clean.flatten(), fs=16000)
dt.wav_write('input_segan.wav', baches_test.noisy.flatten(), fs=16000)
dt.wav_write('output_segan.wav', output_t.d.flatten(), fs=16000)
print('finish!')
def train_img(args, G):
""" train function """
since = time.time()
""" Start iteration """
for epoch in range(1, args.epoch_max + 1):
""" run 1 epoch and get loss """
train_loader, valid_loader, test_loader = data_loader(args)
train_loss = iteration(args, G, train_loader, phase="train")
valid_loss = iteration(args, G, valid_loader, phase="valid")
""" Print loss """
if (epoch % args.save_cycle_of_loss) == 0:
print_loss(epoch, time.time() - since, train_loss, valid_loss)
record_on_csv(args, epoch,
time.time() - since, train_loss, valid_loss)
""" Print image """
if (epoch % args.save_cycle_of_images) == 0:
# visualize_conv_layer(args, G)
test(args, G, test_loader, epoch)
""" Change the ratio of losses """
# if epoch == args.change_cycle_of_loss_ratio:
# args.loss_ratio = 0
""" Decay Learning Rate """
# if (epoch % args.decay_cycle_of_learning_rate) == 0:
# args.learning_rate = args.learning_rate/args.decay_coefficient_of_learning_rate
""" Save model """
if (epoch % args.save_cycle_of_models) == 0:
torch.save(
G.state_dict(), args.save_path_of_models +
"/HGN_train_continued" + str(epoch) + ".pt")
print('======================[ train finished ]======================')
def main():
print("load csv into a pandas dataframe")
dt = data_loader()
data = dt.load_data()
print(f"data has {data.shape}")
data = dt.encode_target(data)
print(
"preprocess data by removing outliers and encoding feature variables")
data = dt.preprocess(data)
#print(data.columns)
print(
"scale data using standardscaler and encoding using pandas get_dummies"
)
data = dt.scale_columns(data)
print(f"data contains {data.columns}")
sam = resample_data()
data = sam.under_sample(data)
print(data['y'].value_counts())
s = split()
data = s.train_test(data)
print(data[0].shape)
classifiers_cv(data[0], data[1], data[2], data[3])
def test(args):
"""
Training
"""
## ~~~~~~~~~~~~~~~~~~~
## Initial settings
## ~~~~~~~~~~~~~~~~~~~
# Input Variable
nn.clear_parameters() # Clear
Input = nn.Variable([1, 3, 64, 64]) # Input
Trues = nn.Variable([1, 1]) # True Value
# Network Definition
Name = "CNN" # Name of scope which includes network models (arbitrary)
Output_test = network(Input, scope=Name, test=True) # Network & Output
Loss_test = F.mean(F.absolute_error(
Output_test, Trues)) # Loss Function (Squared Error)
# Load data
with nn.parameter_scope(Name):
nn.load_parameters(
os.path.join(args.model_save_path,
"network_param_{:04}.h5".format(args.epoch)))
# Training Data Setting
image_data, mos_data = dt.data_loader(test=True)
batches = dt.create_batch(image_data, mos_data, 1)
del image_data, mos_data
truth = []
result = []
for j in range(batches.iter_n):
Input.d, tures = next(batches)
Loss_test.forward(clear_no_need_grad=True)
result.append(Loss_test.d)
truth.append(tures)
result = np.array(result)
truth = np.squeeze(np.array(truth))
# Evaluation of performance
mae = np.average(np.abs(result - truth))
SRCC, p1 = stats.spearmanr(truth,
result) # Spearman's Correlation Coefficient
PLCC, p2 = stats.pearsonr(truth, result)
# Display
print("\n Model Parameter [epoch={0}]".format(args.epoch))
print(" Mean Absolute Error with Truth: {0:.4f}".format(mae))
print(" Speerman's Correlation Coefficient: {0:.3f}".format(SRCC))
print(" Pearson's Linear Correlation Coefficient: {0:.3f}".format(PLCC))
def __init__(self):
self.flags = FLAGS
self.img_height = self.flags.img_height
self.img_width = self.flags.img_width
self.num_classes = self.flags.num_classes
self.batch_size = self.flags.batch_size
self.nEpochs = self.flags.epochs
# self.is_training = self.flags.is_training
self.logdir_train = self.flags.logdir_train
self.logdir_test = self.flags.logdir_test
self.pred_dir = self.flags.pred_dir
self.save_path = self.flags.save_path
self.model_name = self.flags.model_name
self.train_data_loader = data_loader(self.flags.dataset_dir, self.flags.train_txt,
self.img_height, self.img_width, self.batch_size)
self.num_samples_per_epoch = self.train_data_loader.length()
self.val_data_loader = data_loader(self.flags.dataset_dir, self.flags.val_txt,
self.img_height, self.img_width, self.batch_size)
self._build_graph()
self._initialize_session()
self._create_dirs()
def train_epochs(resume=False, use_glove=True):
"""Train multiple opochs"""
print('total epochs: ', cfg.EPOCHS, '; use_glove: ', use_glove)
training_data, word_to_idx, label_to_idx = data_loader()
model, best_acc, start_epoch = get_model(word_to_idx, label_to_idx, resume,
use_glove)
losses = []
loss_function = nn.NLLLoss()
if cfg.RUN_MODE == 'CNN':
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0)
# optimizer = optim.SGD(model.parameters(), lr=0.1)
# optimizer = optim.Adagrad(model.parameters(), lr=0.01, weight_decay=0.01)
else:
# optimizer = optim.Adam(model.parameters(), lr=0.001)
optimizer = optim.SGD(model.parameters(), momentum=0.9, lr=0.1)
# optimizers below are not working
# optimizer = optim.Adagrad(model.parameters(), lr=0.001)
since = time.time()
training_error_rates = []
test_error_rates = []
for epoch in range(1 + start_epoch, start_epoch + cfg.EPOCHS + 1):
train_error, train_loss = train(model, loss_function, optimizer,
training_data, word_to_idx)
losses.append(train_loss)
training_error_rates.append(train_error)
test_error_rate = get_error_rate(model, training=False)
test_error_rates.append(test_error_rate)
acc = 1 - test_error_rate
print('epoch: {}, time: {:.2f}s, cost so far: {}, accurary: {:.3f}'.
format(epoch, (time.time() - since), train_loss.numpy(), acc))
if acc > best_acc:
save_checkpoint(model, acc, epoch)
best_acc = acc
# save all_losses
save_to_pickle('checkpoint/all_losses.p', losses)
save_to_pickle('checkpoint/training_error_rates.p', training_error_rates)
save_to_pickle('checkpoint/test_error_rates.p', test_error_rates)
def get_error_rate_with_two_classes(training=False):
"""
Compute the overall error rate of the trained model.
Combine positive and negative as one class, compared to neutral.
If training is False, use test_data, otherwise training_data.
"""
model = load_checkpoint()['model']
data, word_to_idx, _ = data_loader(training)
targets = torch.LongTensor()
predicts = torch.LongTensor()
for sentences, _targets, seq_lengths in get_batch_data(data,
cfg.BATCH_SIZE,
word_to_idx,
shuffle=True):
_predicts = evaluate_batch(model, sentences, seq_lengths)
targets = torch.cat((targets, _targets), 0)
predicts = torch.cat((predicts, _predicts), 0)
# combine positive and negative as one class
targets[targets == 2] = 1
predicts[predicts == 2] = 1
error_rate = (targets != predicts).sum() / targets.size(0)
print(Counter(targets.numpy()), Counter(predicts.numpy()))
print('error rate: ', error_rate)
idx2label = {i: v for v, i in label_to_idx.items()}
labels = [idx2label[idx] for idx in sorted(idx2label.keys())]
print(
'Report:\n',
metrics.classification_report(targets.numpy(),
predicts.numpy(),
target_names=labels))
print('Confusion matrix: \n',
metrics.confusion_matrix(targets.numpy(), predicts.numpy()))
return error_rate
def bulit_model():
(train_processed, train_label), (test_processed,
test_label) = data_loader(test_rate=0.01)
model = built_attention_model()
# model = multi_gpu_model(model, gpus=2)
model.compile(loss=categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
print('Train...')
print(train_processed.shape)
print(train_label.shape)
print(test_processed.shape)
print(test_label.shape)
model.fit(train_processed,
train_label,
batch_size=256,
epochs=18,
validation_data=(test_processed, test_label))
return model
def get_error_rate(model=None, training=False, report=False):
"""
Compute the overall error rate of the trained model.
If training is False, use test_data, otherwise training_data.
If report is True, print precision, recall, F1-score, and confusion matrix.
"""
model = model or load_checkpoint()['model']
data, word_to_idx, label_to_idx = data_loader(training=training)
targets = torch.LongTensor()
predicts = torch.LongTensor()
for sentences, _targets, seq_lengths in get_batch_data(data,
cfg.BATCH_SIZE,
word_to_idx,
shuffle=True):
_predicts = evaluate_batch(model, sentences, seq_lengths)
targets = torch.cat((targets, _targets), 0)
predicts = torch.cat((predicts, _predicts), 0)
error_rate = (targets != predicts).sum() / targets.size(0)
if report:
print('targets:', Counter(targets.numpy()), 'predicts:',
Counter(predicts.numpy()))
print('error rate: ', error_rate)
idx2label = {i: v for v, i in label_to_idx.items()}
labels = [idx2label[idx] for idx in sorted(idx2label.keys())]
print(
'Report:\n',
metrics.classification_report(targets.numpy(),
predicts.numpy(),
target_names=labels))
print('Confusion matrix: \n',
metrics.confusion_matrix(targets.numpy(), predicts.numpy()))
return error_rate
def train_classifier(epochs, data_directories, model, learning_rate, gpu):
train_loader = data_loader(image_datasets(data_directories[0]), 64, True)
test_loader = data_loader(image_datasets(data_directories[1]), 64, False)
# Cheks if the user specifies the use or not of gpu
if gpu == True and torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
model.to(device)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
epochs = epochs
steps = 0
running_loss = 0
print_every = 5
for epoch in range(epochs):
for inputs, labels in train_loader:
steps += 1
# Moving inputs and labels to the default device
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
output = model.forward(inputs)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
# Testing our network accuracy and loss
if steps % print_every == 0:
# Turning our model into evaluation mode
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(device)
output = model.forward(inputs)
batch_loss = criterion(output, labels)
test_loss += batch_loss.item()
# ACCURACY ( This accurary part of the code I got it from the previous classes in the nanodegree)
ps = torch.exp(output)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(
torch.FloatTensor)).item()
print(f"Epoch {epoch+1}/{epochs}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Test loss: {test_loss/len(test_loader):.3f}.. "
f"Test accuracy: {accuracy/len(test_loader):.3f}")
running_loss = 0
model.train()
return model
def load_and_evaluate(generator, version):
print("Initializing {} dataset".format(version))
path = get_dset_path(DATASET_NAME, version)
_, loader = data_loader(path)
ade, fde = evaluate(loader, generator)
print('{} Dataset: {}, Pred Len: {}, ADE: {:.2f}, FDE: {:.2f}'.format(version, DATASET_NAME, PRED_LEN, ade, fde))
def train(args):
"""
Training
"""
## ~~~~~~~~~~~~~~~~~~~
## Initial settings
## ~~~~~~~~~~~~~~~~~~~
# Input Variable
nn.clear_parameters() # Clear
Input = nn.Variable([args.batch_size, 3, 64, 64]) # Input
Trues = nn.Variable([args.batch_size, 1]) # True Value
# Network Definition
Name = "CNN" # Name of scope which includes network models (arbitrary)
Output = network(Input, scope=Name) # Network & Output
Output_test = network(Input, scope=Name, test=True)
# Loss Definition
Loss = F.mean(F.absolute_error(Output,
Trues)) # Loss Function (Squared Error)
Loss_test = F.mean(F.absolute_error(Output_test, Trues))
# Solver Setting
solver = S.AMSBound(args.learning_rate) # Adam is used for solver
with nn.parameter_scope(
Name): # Get updating parameters included in scope
solver.set_parameters(nn.get_parameters())
# Training Data Setting
image_data, mos_data = dt.data_loader()
batches = dt.create_batch(image_data, mos_data, args.batch_size)
del image_data, mos_data
# Test Data Setting
image_data, mos_data = dt.data_loader(test=True)
batches_test = dt.create_batch(image_data, mos_data, args.batch_size)
del image_data, mos_data
## ~~~~~~~~~~~~~~~~~~~
## Learning
## ~~~~~~~~~~~~~~~~~~~
print('== Start Training ==')
bar = tqdm(total=args.epoch - args.retrain, leave=False)
bar.clear()
loss_disp = None
SRCC = None
# Load data
if args.retrain > 0:
with nn.parameter_scope(Name):
print('Retrain from {0} Epoch'.format(args.retrain))
nn.load_parameters(
os.path.join(args.model_save_path,
"network_param_{:04}.h5".format(args.retrain)))
solver.set_learning_rate(args.learning_rate /
np.sqrt(args.retrain))
## Training
for i in range(args.retrain, args.epoch):
bar.set_description_str('Epoch {0}:'.format(i + 1), refresh=False)
if (loss_disp is not None) and (SRCC is not None):
bar.set_postfix_str('Loss={0:.5f}, SRCC={1:.4f}'.format(
loss_disp, SRCC),
refresh=False)
bar.update(1)
# Shuffling
batches.shuffle()
batches_test.shuffle()
## Batch iteration
for j in range(batches.iter_n):
# Load Batch Data from Training data
Input.d, Trues.d = next(batches)
# Update
solver.zero_grad() # Initialize
Loss.forward(clear_no_need_grad=True) # Forward path
Loss.backward(clear_buffer=True) # Backward path
solver.weight_decay(0.00001) # Weight Decay for stable update
solver.update()
## Progress
# Get result for Display
Input.d, Trues.d = next(batches_test)
Loss_test.forward(clear_no_need_grad=True)
Output_test.forward()
loss_disp = Loss_test.d
SRCC, _ = stats.spearmanr(Output_test.d, Trues.d)
# Display text
# disp(i, batches.iter_n, Loss_test.d)
## Save parameters
if ((i + 1) % args.model_save_cycle) == 0 or (i + 1) == args.epoch:
bar.clear()
with nn.parameter_scope(Name):
nn.save_parameters(
os.path.join(args.model_save_path,
'network_param_{:04}.h5'.format(i + 1)))
import glob
root = "./-334_897/*"
folder = sorted(glob.glob(root))
for path in folder:
image_size = int(path.split("/")[2])
image_path = "./-334_897/" + str(image_size) + "/Image"
mask_path = "./-334_897/" + str(image_size) + "/Mask"
train_set, val_set, test_set = load_dataset(img_path=image_path,
mask_path=mask_path,
img_size=image_size,
test_num=2000,
load=False)
train_loader = data_loader(train_set, 16)
val_loader = data_loader(val_set, 16)
net = UnetGenerator(in_dim=1, out_dim=1, num_filter=16)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)
test = train(net=net,
image_size=image_size,
train_loader=train_loader,
val_loader=val_loader)
test.run(learning_rate=0.001,
patience=10,
mini_batch=50,
epochs=50,
def train(args):
## Sub-functions
## ---------------------------------
## Save Models
def save_models(epoch_num, losses):
# save generator parameter
with nn.parameter_scope('Wave-U-Net'):
nn.save_parameters(
os.path.join(args.model_save_path,
'param_{:04}.h5'.format(epoch_num + 1)))
# save results
np.save(
os.path.join(args.model_save_path,
'losses_{:04}.npy'.format(epoch_num + 1)),
np.array(losses))
## Load Models
def load_models(epoch_num, gen=True, dis=True):
# load generator parameter
with nn.parameter_scope('Wave-U-Net'):
nn.load_parameters(
os.path.join(args.model_save_path,
'param_{:04}.h5'.format(args.epoch_from)))
## Update parameters
class updating:
def __init__(self):
self.scale = 8 if args.halfprec else 1
def __call__(self, solver, loss):
solver.zero_grad() # initialize
loss.forward(clear_no_need_grad=True) # calculate forward
loss.backward(self.scale, clear_buffer=True) # calculate backward
#solver.scale_grad(1. / self.scale) # scaling
solver.update() # update
## Inital Settings
## ---------------------------------
## Create network
# Clear
nn.clear_parameters()
# Variables
noisy = nn.Variable([args.batch_size, 1, 16384], need_grad=False) # Input
clean = nn.Variable([args.batch_size, 1, 16384], need_grad=False) # Desire
# Build Network
# K=2, C=1
target_1, target_2 = Wave_U_Net(noisy)
# Mean Squared Error
loss = (F.mean(F.squared_error(clean, target_1)) +
F.mean(F.squared_error(noisy - clean, target_2))) / 2.
# Optimizer: Adam
solver = S.Adam(args.learning_rate)
# set parameter
with nn.parameter_scope('Wave-U-Net'):
solver.set_parameters(nn.get_parameters())
## Load data & Create batch
clean_data, noisy_data = dt.data_loader()
batches = dt.create_batch(clean_data, noisy_data, args.batch_size)
del clean_data, noisy_data
## Initial settings for sub-functions
fig = figout()
disp = display(args.epoch_from, args.epoch, batches.batch_num)
upd = updating()
## Train
##----------------------------------------------------
print('== Start Training ==')
## Load "Pre-trained" parameters
if args.epoch_from > 0:
print(' Retrain parameter from pre-trained network')
load_models(args.epoch_from)
losses = np.load(
os.path.join(args.model_save_path,
'losses_{:04}.npy'.format(args.epoch_from)))
## Create loss loggers
point = args.epoch_from * ((batches.batch_num + 1) // 10)
loss_len = (args.epoch - args.epoch_from) * (
(batches.batch_num + 1) // 10)
losses = np.append(losses, np.zeros(loss_len))
else:
losses = []
## Create loss loggers
point = len(losses)
loss_len = (args.epoch - args.epoch_from) * (
(batches.batch_num + 1) // 10)
losses = np.append(losses, np.zeros(loss_len))
## Training
for i in range(args.epoch_from, args.epoch):
print('')
print(' =========================================================')
print(' Epoch :: {0}/{1}'.format(i + 1, args.epoch))
print(' =========================================================')
print('')
batches.shuffle()
# Batch iteration
for j in range(batches.batch_num):
print(' Train (Epoch. {0}) - {1}/{2}'.format(
i + 1, j + 2, batches.batch_num))
## Batch setting
clean.d, noisy.d = batches.next(j)
## Updating
upd(solver, loss) # update Generator
## Display
if (j) % 100 == 0:
# Get result for Display
target_1.forward(clear_no_need_grad=True)
target_2.forward(clear_no_need_grad=True)
# Display text
disp(i, j, loss.d)
# Data logger
losses[point] = loss.d
point = point + 1
# Plot
fig.waveform_1(noisy.d[0, 0, :], target_1.d[0, 0, :],
clean.d[0, 0, :])
fig.waveform_2(noisy.d[0, 0, :], target_2.d[0, 0, :],
clean.d[0, 0, :])
fig.loss(losses[0:point - 1])
pg.QtGui.QApplication.processEvents()
## Save parameters
if ((i + 1) % args.model_save_cycle) == 0:
save_models(i, losses) # save model
# fig.save(os.path.join(args.model_save_path, 'plot_{:04}.pdf'.format(i + 1))) # save fig
exporter = pg.exporters.ImageExporter(fig.win.scene(
)) # exportersの直前に pg.QtGui.QApplication.processEvents() を呼ぶ！
exporter.export(
os.path.join(args.model_save_path,
'plot_{:04}.png'.format(i + 1))) # save fig
## Save parameters (Last)
save_models(args.epoch - 1, losses)
exporter = pg.exporters.ImageExporter(fig.win.scene(
)) # exportersの直前に pg.QtGui.QApplication.processEvents() を呼ぶ！
exporter.export(
os.path.join(args.model_save_path,
'plot_{:04}.png'.format(i + 1))) # save fig
f'prec5: {top5.val:.3f} ({top5.avg:.3f}) '
f'Loss: {val_loss.val:.4f} ({val_loss.avg:.4f})')
return val_loss.avg, top1.avg
if __name__ == '__main__':
args = arg_parser()
best_acc = 0
# initialize checkpoint directory
initialize_dir("./checkpoint")
# data loader
train_loader, val_loader = data_loader(args)
# model + loss
model, model_linear = load_model(args)
criterion = load_loss(args)
# optimizer + lr scheduler
optimizer = load_optimizer(args, model_linear)
lr_scheduler = get_lr_scheduler(args, optimizer)
# tensorboardX
os.makedirs(args.log_dir, exist_ok=True)
summary_writer = SummaryWriter(args.log_dir)
end = time.time()
def main():
train_loader, _, test_loader = data.data_loader(data=args.data,
batch_size=args.batch_size)
if len(args.gpu_id) == 1:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id
if args.model == 'resnet18':
model = preact_resnet.resnet18_cifar(
num_classes=args.num_classes).cuda()
elif args.model == 'preactResnet110':
model = preact_resnet.preact_resnet110_cifar(
num_classes=args.num_classes).cuda()
else:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id
if args.model == 'resnet18':
model = nn.DataParallel(
preact_resnet.resnet18_cifar(
num_classes=args.num_classes).cuda(),
device_ids=[
idx for idx in range(int(len(args.gpu_id) + 1) / 2)
])
elif args.model == 'preactResnet110':
model = nn.DataParallel(
preact_resnet.preact_resnet110_cifar().cuda(
num_classes=args.num_classes),
device_ids=[
idx for idx in range(int(len(args.gpu_id) + 1) / 2)
])
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=0.0005)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer=optimizer,
milestones=[160],
gamma=0.1)
if args.individual_loss == True:
criterion = nn.CrossEntropyLoss(reduce=False).cuda()
loss_criterion = nn.MarginRankingLoss(margin=1.0, reduce=False).cuda()
elif args.individual_loss == False:
criterion = nn.CrossEntropyLoss().cuda()
train_accuracy_li = []
train_loss_li = []
train_ranking_loss_li = []
valid_accuracy_li = []
valid_loss_li = []
valid_ranking_loss_li = []
for epoch in range(1, args.epoch + 1):
if args.scheduler == True:
scheduler.step()
print('Epoch {0}/{1}'.format(epoch, args.epoch))
############################ TRAIN ##############################
train_accuracy, train_loss, train_ranking_loss, train_probability, train_correctness, train_individual_loss, train_pred_output = train(
train_loader,
model,
optimizer,
criterion,
ranking_criterion=loss_criterion,
epoch=epoch)
print('accuracy: {0}, loss: {1}, ranking loss: {2}'.format(
train_accuracy, train_loss, train_ranking_loss))
train_accuracy_li.append(train_accuracy)
train_loss_li.append(train_loss)
train_ranking_loss_li.append(train_ranking_loss)
utils.save_log_csv('{}-{}-sgd-train'.format(args.model, args.data),
train_accuracy_li, train_loss_li,
train_ranking_loss_li)
utils.save_prob_csv('{}-{}-sgd-train'.format(args.model, args.data),
epoch, train_correctness, train_probability)
utils.save_loss_csv('{}-{}-sgd-train'.format(args.model, args.data),
epoch, train_individual_loss, train_pred_output)
############################ VALIDATION ##############################
valid_accuracy, valid_loss, valid_ranking_loss, valid_probability, valid_correctness, valid_individual_loss, valid_pred_output = validate(
test_loader,
model,
criterion,
ranking_criterion=loss_criterion,
epoch=epoch)
print('accuracy: {0}, loss: {1}, ranking loss: {2}'.format(
valid_accuracy, valid_loss, valid_ranking_loss))
valid_accuracy_li.append(valid_accuracy)
valid_loss_li.append(valid_loss)
valid_ranking_loss_li.append(valid_ranking_loss)
utils.save_log_csv('{}-{}-sgd-test'.format(args.model, args.data),
valid_accuracy_li, valid_loss_li,
valid_ranking_loss_li)
utils.save_prob_csv('{}-{}-sgd-test'.format(args.model, args.data),
epoch, valid_correctness, valid_probability)
utils.save_loss_csv('{}-{}-sgd-test'.format(args.model, args.data),
epoch, valid_individual_loss, train_pred_output)
from data import data_loader
if __name__ == "__main__":
loader = data_loader(2048, 64, 64, 1000, 5000)
loader.save_npy()
loader.save_embedding_matrix(200)
from collections import Counter
from data import data_loader
from util import load_pickle
data, word_to_idx, label_to_idx = data_loader()
print(len(data))
data, word_to_idx, label_to_idx = data_loader(balance_skew=False)
print(len(data))
print(data[:2])
print(len(word_to_idx))
# print word by length in reverse order
# print('\n'.join(sorted(word_to_idx.keys(), key=len, reverse=True)[:100]))
# path_to_glove = 'GloVe-1.2/vectors.txt'
# with open(path_to_glove, 'r') as f:
# glove_words = set((line.split()[0] for line in f.readlines()))
# our_words = set(word_to_idx.keys())
# print(len(glove_words.intersection(our_words)))
# # get word that is in word_to_idx but not in Glove
# print(len(our_words.difference(glove_words)))
# print(our_words.difference(glove_words))
def train(args):
## Sub-functions
## ---------------------------------
## Save Models
def save_models(epoch_num, cle_disout, fake_disout, losses_gen, losses_dis, losses_ae):
# save generator parameter
with nn.parameter_scope("gen"):
nn.save_parameters(os.path.join(args.model_save_path, 'generator_param_{:04}.h5'.format(epoch_num + 1)))
# save discriminator parameter
with nn.parameter_scope("dis"):
nn.save_parameters(os.path.join(args.model_save_path, 'discriminator_param_{:04}.h5'.format(epoch_num + 1)))
# save results
np.save(os.path.join(args.model_save_path, 'disout_his_{:04}.npy'.format(epoch_num + 1)), np.array([cle_disout, fake_disout]))
np.save(os.path.join(args.model_save_path, 'losses_gen_{:04}.npy'.format(epoch_num + 1)), np.array(losses_gen))
np.save(os.path.join(args.model_save_path, 'losses_dis_{:04}.npy'.format(epoch_num + 1)), np.array(losses_dis))
np.save(os.path.join(args.model_save_path, 'losses_ae_{:04}.npy'.format(epoch_num + 1)), np.array(losses_ae))
## Load Models
def load_models(epoch_num, gen=True, dis=True):
# load generator parameter
with nn.parameter_scope("gen"):
nn.load_parameters(os.path.join(args.model_save_path, 'generator_param_{:04}.h5'.format(args.epoch_from)))
# load discriminator parameter
with nn.parameter_scope("dis"):
nn.load_parameters(os.path.join(args.model_save_path, 'discriminator_param_{:04}.h5'.format(args.epoch_from)))
## Update parameters
class updating:
def __init__(self):
self.scale = 8 if args.halfprec else 1
def __call__(self, solver, loss):
solver.zero_grad() # initialize
loss.forward(clear_no_need_grad=True) # calculate forward
loss.backward(self.scale, clear_buffer=True) # calculate backward
solver.scale_grad(1. / self.scale) # scaling
solver.weight_decay(args.weight_decay * self.scale) # decay
solver.update() # update
## Inital Settings
## ---------------------------------
## Create network
# Clear
nn.clear_parameters()
# Variables
noisy = nn.Variable([args.batch_size, 1, 16384], need_grad=False) # Input
clean = nn.Variable([args.batch_size, 1, 16384], need_grad=False) # Desire
z = nn.Variable([args.batch_size, 1024, 8], need_grad=False) # Random Latent Variable
# Generator
genout = Generator(noisy, z) # Predicted Clean
genout.persistent = True # Not to clear at backward
loss_gen = Loss_gen(genout, clean, Discriminator(noisy, genout))
loss_ae = F.mean(F.absolute_error(genout, clean))
# Discriminator
fake_dis = genout.get_unlinked_variable(need_grad=True)
cle_disout = Discriminator(noisy, clean)
fake_disout = Discriminator(noisy, fake_dis)
loss_dis = Loss_dis(Discriminator(noisy, clean),Discriminator(noisy, fake_dis))
## Solver
# RMSprop.
# solver_gen = S.RMSprop(args.learning_rate_gen)
# solver_dis = S.RMSprop(args.learning_rate_dis)
# Adam
solver_gen = S.Adam(args.learning_rate_gen)
solver_dis = S.Adam(args.learning_rate_dis)
# set parameter
with nn.parameter_scope("gen"):
solver_gen.set_parameters(nn.get_parameters())
with nn.parameter_scope("dis"):
solver_dis.set_parameters(nn.get_parameters())
## Load data & Create batch
clean_data, noisy_data = dt.data_loader()
batches = dt.create_batch(clean_data, noisy_data, args.batch_size)
del clean_data, noisy_data
## Initial settings for sub-functions
fig = figout()
disp = display(args.epoch_from, args.epoch, batches.batch_num)
upd = updating()
## Train
##----------------------------------------------------
print('== Start Training ==')
## Load "Pre-trained" parameters
if args.epoch_from > 0:
print(' Retrain parameter from pre-trained network')
load_models(args.epoch_from, dis=False)
losses_gen = np.load(os.path.join(args.model_save_path, 'losses_gen_{:04}.npy'.format(args.epoch_from)))
losses_dis = np.load(os.path.join(args.model_save_path, 'losses_dis_{:04}.npy'.format(args.epoch_from)))
losses_ae = np.load(os.path.join(args.model_save_path, 'losses_ae_{:04}.npy'.format(args.epoch_from)))
else:
losses_gen = []
losses_ae = []
losses_dis = []
## Create loss loggers
point = len(losses_gen)
loss_len = (args.epoch - args.epoch_from) * ((batches.batch_num+1)//10)
losses_gen = np.append(losses_gen, np.zeros(loss_len))
losses_ae = np.append(losses_ae, np.zeros(loss_len))
losses_dis = np.append(losses_dis, np.zeros(loss_len))
## Training
for i in range(args.epoch_from, args.epoch):
print('')
print(' =========================================================')
print(' Epoch :: {0}/{1}'.format(i + 1, args.epoch))
print(' =========================================================')
print('')
# Batch iteration
for j in range(batches.batch_num):
print(' Train (Epoch. {0}) - {1}/{2}'.format(i+1, j+1, batches.batch_num))
## Batch setting
clean.d, noisy.d = batches.next(j)
#z.d = np.random.randn(*z.shape)
z.d = np.zeros(z.shape)
## Updating
upd(solver_gen, loss_gen) # update Generator
upd(solver_dis, loss_dis) # update Discriminator
## Display
if (j+1) % 10 == 0:
# Get result for Display
cle_disout.forward()
fake_disout.forward()
loss_ae.forward(clear_no_need_grad=True)
# Display text
disp(i, j, loss_gen.d, loss_dis.d, loss_ae.d)
# Data logger
losses_gen[point] = loss_gen.d
losses_ae[point] = loss_ae.d
losses_dis[point] = loss_dis.d
point = point + 1
# Plot
fig.waveform(noisy.d[0,0,:], genout.d[0,0,:], clean.d[0,0,:])
fig.loss(losses_gen[0:point-1], losses_ae[0:point-1], losses_dis[0:point-1])
fig.histogram(cle_disout.d, fake_disout.d)
pg.QtGui.QApplication.processEvents()
## Save parameters
if ((i+1) % args.model_save_cycle) == 0:
save_models(i, cle_disout.d, fake_disout.d, losses_gen[0:point-1], losses_dis[0:point-1], losses_ae[0:point-1]) # save model
exporter = pg.exporters.ImageExporter(fig.win.scene()) # Call pg.QtGui.QApplication.processEvents() before exporters!!
exporter.export(os.path.join(args.model_save_path, 'plot_{:04}.png'.format(i + 1))) # save fig
## Save parameters (Last)
save_models(args.epoch-1, cle_disout.d, fake_disout.d, losses_gen, losses_dis, losses_ae)
def main():
# Training settings
parser = argparse.ArgumentParser(
description="Measuring Privacy and Fairness Trade-offs")
parser.add_argument(
"-rn",
"--run-name",
required=True,
type=str,
help="Define run name for logging",
)
parser.add_argument(
"-b",
"--batch-size",
type=int,
default=128,
metavar="B",
help="Input batch size for training (default: 128)",
)
parser.add_argument(
"--test-batch-size",
type=int,
default=4119,
metavar="TB",
help="Input batch size for testing (default: 1024)",
)
parser.add_argument(
"-n",
"--epochs",
type=int,
default=20,
metavar="N",
help="Number of epochs to train (default: 20)",
)
parser.add_argument(
"-r",
"--n-runs",
type=int,
default=1,
help="Number of runs to average on (default: 1)",
)
parser.add_argument(
"--lr",
type=float,
default=.1,
metavar="LR",
help="Learning rate (default: .1)",
)
parser.add_argument(
"--sigma",
type=list,
#default=[3.0, 0.6],
default=[
0, 3.0, 2.85, 2.6, 2.45, 2.3, 2.15, 2.0, 1.85, 1.6, 1.45, 1.3,
1.15, 1.0, 0.85, 0.6, 0.45, 0.3, 0.15
],
metavar="S",
help="Noise multiplier (default [0, 0.1, 0.5, 1.0])",
)
parser.add_argument(
"-c",
"--max-per-sample-grad_norm",
type=float,
default=1.0,
metavar="C",
help="Clip per-sample gradients to this norm (default 1.0)",
)
parser.add_argument(
"--delta",
type=float,
default=1e-5,
metavar="D",
help="Target delta (default: 1e-5)",
)
parser.add_argument(
"--device",
type=str,
default="cuda",
help="GPU ID for this process (default: 'cuda')",
)
parser.add_argument(
"--save-model",
action="store_true",
default=False,
help="Save the trained model (default: false)",
)
parser.add_argument(
"--disable-dp",
action="store_true",
default=False,
help="Disable privacy training and just train with vanilla SGD",
)
parser.add_argument(
"--dataset",
type=str,
#default="bank",
required=True,
help=
"Specify the dataset you want to test on. (bank: bank marketing, adult: adult census)",
)
parser.add_argument(
"--train-data-path",
type=str,
default="./bank-data/bank-additional-full.csv",
help="Path to train data",
)
parser.add_argument(
"--test-data-path",
type=str,
default="./bank-data/bank-additional.csv",
help="Path to test data",
)
parser.add_argument(
"--num-teachers",
type=int,
default=0,
help="Number of PATE teacher (default=3)",
)
parser.add_argument(
"--sensitive",
type=str,
required=True,
help="Name of sensitive column",
)
args = parser.parse_args()
device = torch.device(args.device)
# for i in range(args.n_runs):
for i, s in enumerate(args.sigma):
if args.num_teachers == 0 or s == 0:
dataset = data_loader(args, s)
train_data, test_data = dataset.__getitem__()
cat_emb_size, num_conts = dataset.get_input_properties()
train_size, test_size = dataset.__len__()
sensitive_cat_keys = dataset.getkeys()
sensitive_idx = dataset.get_sensitive_idx()
print(sensitive_cat_keys)
else:
dataset = data_loader(args, s)
train_size, test_size = dataset.__len__()
teacher_loaders = dataset.train_teachers()
student_train_loader, student_test_loader = dataset.student_data()
cat_emb_size, num_conts = dataset.get_input_properties()
sensitive_cat_keys = dataset.getkeys()
sensitive_idx = dataset.get_sensitive_idx()
print(sensitive_cat_keys)
print("!!!!!! DATA LOADED")
#run_results = []
wandb.init(project="project3",
name=args.run_name,
config={
"run_name": args.run_name,
"architecture": 'RegressionModel',
"dataset": args.dataset,
"batch_size": args.batch_size,
"n_epoch": args.epochs,
"learning_rate": args.lr,
"sigma(noise)": s,
"disable_dp": args.disable_dp,
})
config = wandb.config
model = RegressionModel(emb_szs=cat_emb_size,
n_cont=num_conts,
emb_drop=0.04,
out_sz=1,
szs=[1000, 500, 250],
drops=[0.001, 0.01, 0.01],
y_range=(0, 1)).to(device)
for layer in model.children():
if hasattr(layer, 'reset_parameters'):
layer.reset_parameters()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0)
if not args.disable_dp:
if s > 0:
privacy_engine = PrivacyEngine(
model,
batch_size=args.batch_size,
sample_size=train_size,
alphas=[1 + x / 10.0
for x in range(1, 100)] + list(range(12, 64)),
noise_multiplier=s,
max_grad_norm=args.max_per_sample_grad_norm,
secure_rng=False,
)
privacy_engine.attach(optimizer)
if args.num_teachers == 0 or s == 0:
if i == 0: # print model properties
print(model, '\n')
print(
"\n=== RUN # {} ====================================\n".format(
i))
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_data, criterion, optimizer,
epoch, s)
"""
batch = next(iter(train_data))
cats, conts, _ = batch
test_batch = next(iter(test_data))
test_cats, test_conts, _ = test_batch
explainer = shap.KernelExplainer(model, [cats.numpy(), conts.numpy()])
print(explainer)
shap_values = explainer.shap_values(cats.numpy())
shap.plots.bar(shap_values)
exit():q
"""
accuracy, avg_loss, avg_precision, avg_recall, avg_eq_odds, avg_tpr, avg_dem_par, cm, sub_cm, overall_results = test(
args, model, device, test_data, test_size, sensitive_idx)
else: # PATE MODEL
print("!!!!!! ENTERED HERE")
#model_rf = RandomForestClassifier(random_state=42, warm_start=True)
teacher_models = train_models(args, model, teacher_loaders,
criterion, optimizer, device)
preds, student_labels = aggregated_teacher(teacher_models,
student_train_loader, s,
device)
accuracy, avg_loss, avg_precision, avg_recall, avg_eq_odds, avg_tpr, avg_dem_par, cm, sub_cm, overall_results = test_student(
args, student_train_loader, student_labels,
student_test_loader, test_size, cat_emb_size, num_conts,
device, sensitive_idx)
"""
data_dep_eps, data_ind_eps = pate.perform_analysis(teacher_preds=preds, indices=student_labels,
noise_eps=s, delta=1e-5)
print("Data Independent Epsilon:", data_ind_eps)
print("Data Dependent Epsilon:", data_dep_eps)
"""
#t = [accuracy, avg_loss, avg_precision, avg_recall, avg_eq_odds, avg_tpr, avg_dem_par, cm, sub_cm, overall_results]
#[print(type(i)) for i in t]
#print("\nTest set: Average loss: {:.4f}, Accuracy: {:.2f}%\n".format(avg_loss,accuracy))
result = """
===================
Test set: {}
accuracy: {:.4f}
average loss: {:.4f}
precision: {:.4f}
recall: {:.4f}
sub_pre_rec:
{}
cm:
{}
sub_cm:
{}
avg_eq_odds: {:.4f}
avg_tpr: {:.4f}
avg_dem_par: {:.4f}
""".format(args.run_name, accuracy, avg_loss, avg_precision, avg_recall,
overall_results, cm, sub_cm, avg_eq_odds, avg_tpr, avg_dem_par)
# append run result
file_path = 'out//all_results.' + args.run_name
file_object = open(file_path, 'a+')
file_object.write(result)
file_object.close()
print(result)
log_dict = {
"accuracy": accuracy,
"avg_loss": avg_loss,
"precision": avg_precision,
"recall": avg_recall,
"avg_eq_odds": avg_eq_odds,
"avg_tpr": avg_tpr,
"avg_dem_par": avg_dem_par,
"tn": cm[0],
"fp": cm[1],
"fn": cm[2],
"tp": cm[3]
}
"""
for j in avg_recall_by_group.keys():
category = sensitive_cat_keys[j]
value = avg_recall_by_group[j]
log_dict[category] = value
"""
print(log_dict)
wandb.log(log_dict)
from data import data_loader
from option import option
import torch
opt = option()
data = data_loader(opt.dataset, 'resize', batchsize=8)
for i, batch in enumerate(data):
print(batch)
def test(args):
## Load data & Create batch
clean_data, noisy_data, length_data = dt.data_loader(test=True,
need_length=True)
print(clean_data.shape)
# Batch
# - Proccessing speech interval can be adjusted by "start_frame" and "start_frame".
# - "None" -> All speech in test dataset.
output_ts = []
bt_idx = 0
test_batch_size = args.batch_size
for i in range(clean_data.shape[0] // (test_batch_size * 2)):
print(i, "/", clean_data.shape[0] // (test_batch_size * 2))
batches_test = dt.create_batch_test(
clean_data[bt_idx:bt_idx + test_batch_size * 2],
noisy_data[bt_idx:bt_idx + test_batch_size * 2],
start_frame=0,
stop_frame=test_batch_size * 2)
## Create network
# Variables
noisy_t = nn.Variable(batches_test.noisy.shape) # Input
# Network (Only Generator)
output_t, _ = Wave_U_Net(noisy_t)
## Load parameter
# load generator
with nn.parameter_scope('Wave-U-Net'):
nn.load_parameters(
os.path.join(args.model_save_path,
"param_{:04}.h5".format(args.epoch)))
## Validation
noisy_t.d = batches_test.noisy
output_t.forward()
## Create wav files
output = output_t.d.flatten()
output_ts.append(output)
bt_idx += (test_batch_size * 2)
if (clean_data.shape[0] % (test_batch_size * 2)) != 0:
last_batch_size_2 = clean_data.shape[0] % (test_batch_size * 2)
print(last_batch_size_2)
batches_test = dt.create_batch_test(
clean_data[bt_idx:bt_idx + last_batch_size_2],
noisy_data[bt_idx:bt_idx + last_batch_size_2],
start_frame=0,
stop_frame=last_batch_size_2)
## Create network
# Variables
noisy_t = nn.Variable(batches_test.noisy.shape) # Input
# Network (Only Generator)
## Load parameter
output_t, _ = Wave_U_Net(noisy_t)
# load generator
with nn.parameter_scope('Wave-U-Net'):
nn.load_parameters(
os.path.join(args.model_save_path,
"param_{:04}.h5".format(args.epoch)))
## Validation
noisy_t.d = batches_test.noisy
output_t.forward()
## Create wav files
output = output_t.d.flatten()
output_ts.append(output)
bt_idx += (last_batch_size_2)
output = output_ts[0]
for i in range(1, len(output_ts)):
output = np.concatenate([output, output_ts[i]], axis=0)
print(len(output))
output = np.array(output)
print(output.shape)
idx_cnt = 0
for i in range(len(length_data['name'])):
print("saving", i, length_data['name'][i], "...")
outwav = output[idx_cnt:idx_cnt + length_data['length'][i]]
print(outwav.shape)
idx_cnt += length_data['length'][i]
print(idx_cnt)
dt.wav_write((args.wav_save_path + '/' + 'ests_' +
os.path.basename(length_data['name'][i])),
np.array(outwav),
fs=16000)
print('finish!')
import numpy as np
import tensorflow as tf
from data import modelCNN, preprocess_img_path, data_loader
from models import Encoder, Decoder
from PIL import Image
from nltk.translate.bleu_score import corpus_bleu
import matplotlib.pyplot as plt
from train import validate
import math
if __name__ == "__main__":
loader = data_loader(features_shape=2048,
attention_features_shape=64,
batch_size=256,
buffer_size=1000,
top_k=5000)
dataset_train = loader.load_dataset("train")
dataset_test = loader.load_dataset("test")
tokenizer = loader.tokenizer
# loading model
embedding_matrix = np.load(
"./content/drive/My Drive/datasets/embeddingmatrix.npy")
encoder = Encoder(encoder_dim=200)
decoder = Decoder(embedding_dim=200,
vocab_size=loader.top_k + 1,
units=512,
embedding_matrix=embedding_matrix)
optimizer = tf.keras.optimizers.Adam()
def run(EPOCHS):
## Load data and init
loader = data_loader(
features_shape=2048,
attention_features_shape=64,
batch_size=64,
buffer_size=1000,
top_k=5000,
)
dataset_train = loader.load_dataset("train")
dataset_test = loader.load_dataset("test")
tokenizer = loader.tokenizer
embedding_dim = 200
encoder_dim = embedding_dim
units = 512
vocab_size = loader.top_k + 1
num_steps = len(loader.train_path) // loader.batch_size
## Load model
embedding_matrix = np.load(
"/content/drive/My Drive/datasets/embeddingmatrix.npy")
encoder = Encoder(encoder_dim)
decoder = Decoder(embedding_dim, vocab_size, units, embedding_matrix)
optimizer = tf.keras.optimizers.Adam()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
from_logits=True, reduction="none")
## Load checkpoint
checkpoint_path = "/content/drive/My Drive/datasets/modelcheckpoint/embedding"
ckpt = tf.train.Checkpoint(encoder=encoder,
decoder=decoder,
optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt,
checkpoint_path,
max_to_keep=3)
start_epoch = 0
if ckpt_manager.latest_checkpoint:
start_epoch = int(ckpt_manager.latest_checkpoint.split("-")[-1])
ckpt.restore(ckpt_manager.latest_checkpoint)
# Running
BLEU_1, BLEU_2, BLEU_3, BLEU_4 = [], [], [], []
loss_plot = []
for epoch in range(start_epoch, EPOCHS):
start = time()
total_loss = 0
print("---Training---Epoch {}".format(epoch))
for (batch, (img_tensor, target)) in enumerate(dataset_train):
batch_loss, t_loss = train_step(encoder, decoder, optimizer,
tokenizer, loss_object, img_tensor,
target)
total_loss += t_loss
loss_plot.append(total_loss / num_steps)
if epoch % 10 == 0:
ckpt_manager.save()
print("---Testing---Epoch {}".format(epoch))
bleu_1, bleu_2, bleu_3, bleu_4 = 0, 0, 0, 0
for (batch, (img_tensor, target)) in enumerate(dataset_test):
hypotheses, references = validate(encoder, decoder, optimizer,
tokenizer, img_tensor,
target)
bleu_1 += corpus_bleu(references,
hypotheses,
weights=(1, 0, 0, 0))
bleu_2 += corpus_bleu(references,
hypotheses,
weights=(0.5, 0.5, 0, 0))
bleu_3 += corpus_bleu(references,
hypotheses,
weights=(0.33, 0.33, 0.33, 0))
bleu_4 += corpus_bleu(references,
hypotheses,
weights=(0.25, 0.25, 0.25, 0.25))
if batch == 5:
break
bleu_1, bleu_2, bleu_3, bleu_4 = (
bleu_1 / (batch + 1),
bleu_2 / (batch + 1),
bleu_3 / (batch + 1),
bleu_4 / (batch + 1),
)
print("Bleu_1: {}".format(bleu_1))
print("Bleu_2: {}".format(bleu_2))
print("Bleu_3: {}".format(bleu_3))
print("Bleu_4: {}".format(bleu_4))
BLEU_1.append(bleu_1)
BLEU_2.append(bleu_2)
BLEU_3.append(bleu_3)
BLEU_4.append(bleu_4)
print("Epoch {} Loss {:.6f}".format(epoch, total_loss / num_steps))
print("Time taken for 1 epoch {} sec\n".format(time() - start))
return BLEU_1, BLEU_2, BLEU_3, BLEU_4, loss_plot
if args.model_path != '':
if os.path.isfile(args.model_path):
print('loading model parameters from {}'.format(args.model_path))
model.load_state_dict(torch.load(args.model_path))
else:
print('no found {}'.format(args.model_path))
# Define loss function 、 optimizer and scheduler to adjust lr
criterion = nn.CrossEntropyLoss().to(args.device)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=args.step_size,
gamma=args.gamma)
best_result = {'epoch': 1, 'accuracy': 0.}
# Load train and val dataset for training
train_loader = data_loader(args, train=True, val=True)
for epoch in range(args.begin_epoch, args.epochs + 1):
adjust_learning_rate(scheduler)
train_accuracy, train_loss = train_model(args, epoch, model,
train_loader, criterion,
optimizer, scheduler, None)
print('=> Saving model...\n')
file_path = os.path.join(args.result_path,
'save_{}_{}.pth'.format(args.model, epoch))
torch.save(model.state_dict(), file_path)
def run(param, args):
source = os.path.basename(args.source).split('.')[0]
target = os.path.basename(args.target).split('.')[0]
flag = False if 'trainNum' == args.testType else True
test_num = 10
if flag:
# Load source and target data
param["source_data"], param["source_label"] = data.data_loader(args.source, param["inp_dims"], sample_num=25)
# Encode labels into one-hot format
clsNum = len(set(param["source_label"]))
param["source_label"] = data.one_hot_encoding(param["source_label"], clsNum)
else:
print('will run train num test, so not loading training data at first')
if 'nShot' == args.testType:
print('run n_shot test...')
n_shot_list = [1, 5, 10, 15, 20]
#n_shot_list = [20]
outfile = os.path.join(ResDir, 'ADA_one_source_{}_target_{}_res.txt'.format(source, target))
f = open(outfile, 'a+')
print('\n\n##################### test time is: {}####################'.format(time.ctime()), file=f, flush=True)
for n_shot in n_shot_list:
acc_list = []
time_last_list = []
for i in range(test_num):
# Train phase
signature_dict, test_dict, sites = utility.getDataDict(args.target, n_shot=n_shot, data_dim=param['inp_dims'], train_pool_size=20, test_size=70)
target_data, target_label = mytools.datadict2data(signature_dict)
print('target data shape: ', target_data.shape)
target_data = target_data[:, :, np.newaxis]
target_label = data.one_hot_encoding(target_label, len(set(target_label)))
param["target_data"], param["target_label"] = target_data, target_label
model_path, time_last = train(param, args)
time_last_list.append(time_last)
print('training time last: ', time_last)
# Test phase
test_opts = test.MyOpts(model_path, nShot=n_shot, tuning=True, aug=0, exp_type=args.exp_type)
test_opts.nShot = n_shot
test_params = test.generate_default_params(test_opts)
inp_shape = (param["inp_dims"], 1)
_, acc = test.run(test_opts, signature_dict, test_dict, params=test_params, emb_size=param['embsz'], inp_shape=inp_shape, test_times=1)
acc_list.append(acc)
print('acc of source {} and target {} with n_shot {} is: {:f}'.format(source, target, n_shot, acc))
resLine = 'acc of source {} and target {} with n_shot {} is: {:f}, stdev is: {:f}, time last: {:f}\n\n'.format(source, target, n_shot, mean(acc_list), stdev(acc_list), mean(time_last_list))
print(resLine, file=f, flush=True)
f.close()
elif 'aug' == args.testType:
print('will run aug test...')
pass
elif 'trainNum' == args.testType:
print('will run train num test...')
n_shot = 20
outfile = os.path.join(ResDir, 'trainNumTest_ADA_one_source_{}_target_{}_res.txt'.format(source, target))
f = open(outfile, 'a+')
print('\n\n################### test time is: {} ####################'.format(time.ctime()), file=f, flush=True)
print('test with N shot num: {}'.format(n_shot), file=f, flush=True)
trainNumList = [25, 50, 75, 100, 125]
for trainNum in trainNumList:
acc_list, time_last_list = [], []
# load training data accord to the train num
param["source_data"], param["source_label"] = data.data_loader(args.source, param["inp_dims"], sample_num=trainNum)
print('train data shape is: ', np.array(param['source_data']).shape)
clsNum = len(set(param["source_label"]))
param["source_label"] = data.one_hot_encoding(param["source_label"], clsNum)
for i in range(test_num):
# Train phase
signature_dict, test_dict, sites = utility.getDataDict(args.target, n_shot=n_shot, data_dim=param['inp_dims'], train_pool_size=20, test_size=70)
target_data, target_label = mytools.datadict2data(signature_dict)
target_data = target_data[:, :, np.newaxis]
target_label = data.one_hot_encoding(target_label, len(set(target_label)))
param["target_data"], param["target_label"] = target_data, target_label
model_path, time_last = train(param, args)
time_last_list.append(time_last)
# Test phase
test_opts = test.MyOpts(model_path, nShot=n_shot, tuning=True, aug=0, exp_type=args.exp_type)
test_opts.nShot = n_shot
test_params = test.generate_default_params(test_opts)
inp_shape = (param["inp_dims"], 1)
_, acc = test.run(test_opts, signature_dict, test_dict, params=test_params, emb_size=param['embsz'], inp_shape=inp_shape, test_times=1)
acc_list.append(acc)
print('acc of source {} and target {} with n_shot {} is: {:f}'.format(source, target, n_shot, acc))
resLine = 'acc of source {} and target {} with n_shot {} is: {:f}, stdev is: {:f}, training time last: {:f}'.format(source, target, n_shot, mean(acc_list), stdev(acc_list), mean(time_last_list))
print(resLine, file=f, flush=True)
f.close()
elif 'trainTime' == args.testType:
# Train phase
n_shot = 20
signature_dict, test_dict, sites = utility.getDataDict(args.target, n_shot=n_shot, data_dim=param['inp_dims'], train_pool_size=20, test_size=70)
target_data, target_label = mytools.datadict2data(signature_dict)
target_data = target_data[:, :, np.newaxis]
target_label = data.one_hot_encoding(target_label, len(set(target_label)))
param["target_data"], param["target_label"] = target_data, target_label
model_path, time_last = train(param, args)
print('training time last: ', time_last)
else:
raise
import requests
from starlette.testclient import TestClient
from data import data_loader, data_config
app = fastapi.FastAPI()
get_url = 'http://cyn.apustech.cn:8000/get_model'
post_url = 'http://cyn.apustech.cn:8000/send_data'
client = TestClient(app)
# get_url = 'http://localhost:8000/get_model'
# post_url = 'http://localhost:8000/send_data'
get_param = {
"index": 10,
}
source_loader = data_loader(data_config.source_speed, data_config.data_type, 'source', is_fft=True)
data, label = next(iter(source_loader))
data = data[:2]
t = data.numpy()
print(t.dtype, t)
s: bytes = base64.b64encode(t)
post_param = {
"signal": s.decode("utf-8")
}
# 这里是去请求后端
def get(url, param):
data = requests.get(url, param)
print(data)
y = data.json()
print(y)
def main():
# Record the best epoch and accuracy
best_result = {'epoch': 1, 'accuracy': 0.}
args = parse_args()
# Use model name to name env's
args.env = args.model
vis = Visualize(env=args.env) if not args.close_visdom else None
# Create file to storage result and checkpoint
if args.root_path != '':
args.result_path = os.path.join(args.root_path, args.result_path)
args.checkpoint_path = os.path.join(args.root_path,
args.checkpoint_path)
args.pretrained_models_path = os.path.join(args.root_path,
args.pretrained_models_path)
if not os.path.exists(args.result_path):
os.mkdir(args.result_path)
if not os.path.exists(args.checkpoint_path):
os.mkdir(args.checkpoint_path)
if not os.path.exists(args.pretrained_models_path):
os.mkdir(args.pretrained_models_path)
if args.resume_path:
args.resume_path = os.path.join(args.checkpoint_path,
args.resume_path)
# Set manual seed to reproduce random value
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
# Create model
if not torch.cuda.is_available():
args.device = torch.device('cpu')
else:
args.device = torch.device(args.device)
model = get_model(args)
model.to(args.device)
print(model)
# Define loss function 、 optimizer and scheduler to adjust lr
criterion = nn.CrossEntropyLoss().to(args.device)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=args.step_size,
gamma=args.gamma)
# optimizer = optim.Adam(model.parameters(), lr=args.lr)
# Continue training from checkpoint epoch with checkpoint parameters
if args.resume_path:
if os.path.isfile(args.resume_path):
print("=> loading checkpoint '{}'...".format(args.resume_path))
checkpoint = torch.load(args.resume_path)
args.begin_epoch = checkpoint['epoch'] + 1
best_result = checkpoint['best_result']
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
else:
print("=> no checkpoint found at '{}'".format(args.resume_path))
# Load dataset
train_loader = data_loader(args, train=True)
val_loader = data_loader(args, val=True)
test_loader = data_loader(args, test=True)
# Begin to train
since = time.time()
for epoch in range(args.begin_epoch, args.epochs + 1):
adjust_learning_rate(scheduler)
train_accuracy, train_loss = train_model(args, epoch, model,
train_loader, criterion,
optimizer, scheduler, vis)
# Verify accuracy and loss after training
val_accuracy, val_loss = val_model(args, epoch, best_result, model,
val_loader, criterion, vis)
# Plot train and val's accuracy and loss each epoch
accuracy = [[train_accuracy], [val_accuracy]]
loss = [[train_loss], [val_loss]]
vis.plot2('accuracy', accuracy, ['train', 'val'])
vis.plot2('loss', loss, ['train', 'val'])
# Save checkpoint model each checkpoint interval and keep the last one
if epoch % args.checkpoint_interval == 0 or epoch == args.epochs:
save_checkpoint(args, epoch, best_result, model, optimizer,
scheduler)
# Total time to train
time_elapsed = time.time() - since
print('Training complete in {}m {}s'.format(time_elapsed // 60,
time_elapsed % 60))
# Test model with the best val model parameters
best_model_path = os.path.join(
args.result_path, '{}_{}.pth'.format(args.model, best_result['epoch']))
print("Using '{}' for test...".format(best_model_path))
model.load_state_dict(torch.load(best_model_path))
test_model(args, model, test_loader)
def main():
train_path = get_dset_path(DATASET_NAME, 'train')
val_path = get_dset_path(DATASET_NAME, 'val')
long_dtype, float_dtype = get_dtypes()
print("Initializing train dataset")
train_dset, train_loader = data_loader(train_path)
print("Initializing val dataset")
_, val_loader = data_loader(val_path)
iterations_per_epoch = len(train_dset) / D_STEPS
NUM_ITERATIONS = int(iterations_per_epoch * NUM_EPOCHS)
print('There are {} iterations per epoch'.format(iterations_per_epoch))
generator = TrajectoryGenerator()
generator.apply(init_weights)
generator.type(float_dtype).train()
print('Here is the generator:')
print(generator)
discriminator = TrajectoryDiscriminator()
discriminator.apply(init_weights)
discriminator.type(float_dtype).train()
print('Here is the discriminator:')
print(discriminator)
optimizer_g = optim.Adam(generator.parameters(), lr=G_LR)
optimizer_d = optim.Adam(discriminator.parameters(), lr=D_LR)
t, epoch = 0, 0
t0 = None
min_ade = None
while t < NUM_ITERATIONS:
gc.collect()
d_steps_left = D_STEPS
g_steps_left = G_STEPS
epoch += 1
print('Starting epoch {}'.format(epoch))
for batch in train_loader:
if d_steps_left > 0:
losses_d = discriminator_step(batch, generator, discriminator,
gan_d_loss, optimizer_d)
d_steps_left -= 1
elif g_steps_left > 0:
losses_g = generator_step(batch, generator, discriminator,
gan_g_loss, optimizer_g)
g_steps_left -= 1
if d_steps_left > 0 or g_steps_left > 0:
continue
if t % PRINT_EVERY == 0:
print('t = {} / {}'.format(t + 1, NUM_ITERATIONS))
for k, v in sorted(losses_d.items()):
print(' [D] {}: {:.3f}'.format(k, v))
for k, v in sorted(losses_g.items()):
print(' [G] {}: {:.3f}'.format(k, v))
print('Checking stats on val ...')
metrics_val = check_accuracy(val_loader, generator,
discriminator, gan_d_loss)
print('Checking stats on train ...')
metrics_train = check_accuracy(train_loader,
generator,
discriminator,
gan_d_loss,
limit=True)
for k, v in sorted(metrics_val.items()):
print(' [val] {}: {:.3f}'.format(k, v))
for k, v in sorted(metrics_train.items()):
print(' [train] {}: {:.3f}'.format(k, v))
if min_ade is None or metrics_val['ade'] < min_ade:
min_ade = metrics_val['ade']
checkpoint = {
't': t,
'g': generator.state_dict(),
'd': discriminator.state_dict(),
'g_optim': optimizer_g.state_dict(),
'd_optim': optimizer_d.state_dict()
}
print("Saving checkpoint to model.pt")
torch.save(checkpoint, "model.pt")
print("Done.")
t += 1
d_steps_left = D_STEPS
g_steps_left = G_STEPS
if t >= NUM_ITERATIONS:
break
