def plot_loss_landscape(models, device, init, save_path=None, verbose=True):
"""Plotting the loss landscape and creating a file for replotting"""
train_loader, test_loader = load_data('mnist', path='../data')
criterion = nn.CrossEntropyLoss()
xv, yv, loss, directions, x_coord, y_coord = loss_landscape_pca_2d(
models, test_loader, criterion, device, verbose=verbose)
# fig, ax = plt.subplots()
# CS = ax.contour(xv, yv, loss, levels=20)
# ax.clabel(CS, inline=1, fontsize=10)
# ax.set_title('Loss Landscape (with PCA)')
# ax.plot(x_coord, y_coord, marker='.')
if save_path != None:
print("Saving plot information in {}init_{}.npz\n".format(
save_path, init))
# np.savez('{}.npz'.format(save_path[:-4]), xv=xv, yv=yv, loss=loss, xdir=np.asarray(directions[0]), ydir=np.asarray(directions[1]), x=x_coord, y=y_coord)
np.savez('{}init_{}.npz'.format(save_path, init),
xv=xv,
yv=yv,
loss=loss,
x=x_coord,
y=y_coord)
processor = Sst2Processor()
label_list = processor.get_labels()
logging.info("Predict with {} labels: {}".format(len(label_list),
label_list))
tokenizer = BertTokenizer.from_pretrained(
Config.PRE_TRAINED_MODEL_BERT_BASE_UNCASED,
do_lower_case=Config.DO_LOWER_CASE)
test_examples = processor.get_dev_examples(Config.DATA_DIR)
logging.info(
"loaded {} test examples (take care: we use the evaluation-data here as no labels for test are "
"available!)".format(len(test_examples)))
test_data_loader = load_data(test_examples, label_list, tokenizer,
Config.MAX_SEQ_LENGTH, Config.EVAL_BATCH_SIZE,
DataType.TEST)
model = load_saved_model(Config.TRAINED_MODEL_FOR_PREDICTION,
Config.MODEL_OUTPUT_DIR, len(label_list))
model.to(device)
prediction = predict(test_examples, test_data_loader, model, device)
print("Prediction done! Result-Shape: {}".format(prediction.shape))
print(prediction[:10])
print(
classification_report(list(prediction['true_label']),
list(prediction['predicted_label'])))
model = get_pretrained_model(Config.PRE_TRAINED_MODEL_BERT_BASE_UNCASED,
len(label_list),
Config.PRE_TRAINED_MODEL_CACHE_DIR)
model.to(device)
logging.info("initialized BERT-model")
num_train_steps = int(
len(train_examples) / Config.TRAIN_BATCH_SIZE) * Config.NUM_EPOCHS
optimizer = build_optimizer(model, num_train_steps, Config.LEARNING_RATE,
Config.WARMUP_PROPORTION, Config.WEIGHT_DECAY)
logging.info("Built optimizer: {}".format(optimizer))
eval_examples = processor.get_dev_examples(Config.DATA_DIR)
evaluation_data_loader = load_data(eval_examples, label_list, tokenizer,
Config.MAX_SEQ_LENGTH,
Config.EVAL_BATCH_SIZE,
DataType.EVALUATION)
evaluation = Evaluation(evaluation_data_loader, exp_name,
Config.MODEL_OUTPUT_DIR)
logging.info("loaded and initialized evaluation examples {}".format(
len(eval_examples)))
training = Training()
training_data_loader = load_data(train_examples, label_list, tokenizer,
Config.MAX_SEQ_LENGTH,
Config.TRAIN_BATCH_SIZE,
DataType.TRAINING)
training.fit(device, training_data_loader, model, optimizer, evaluation,
Config.NUM_EPOCHS)
def main():
# saving path
save_dir = 'results/aexcov'
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# parse parameters
parser = argparse.ArgumentParser(description='AE-XCov')
parser.add_argument('--img_sz',
type=int,
default=64,
help='Image size (images have to be squared)')
parser.add_argument('--batch_size',
type=int,
default=128,
help='Batch size')
parser.add_argument("--attr_size",
type=int,
default=40,
help='Attribute vector size')
parser.add_argument("--latent_size",
type=int,
default=1000,
help='Latent vector size')
parser.add_argument('--n_epochs',
type=int,
default=25,
help='Total number of epochs')
parser.add_argument('--n_train',
type=int,
default=162770,
help='The number of training samples')
parser.add_argument('--n_valid',
type=int,
default=19867,
help='The number of validation samples')
parser.add_argument('--n_test',
type=int,
default=19962,
help='The number of test samples')
parser.add_argument('--lr_encoder',
type=float,
default=1e-4,
help='Learning rate for encoder')
parser.add_argument('--lr_decoder',
type=float,
default=1e-4,
help='Learning rate for decoder')
parser.add_argument('--lambda_class',
type=float,
default=1,
help='Image classification coefficient for encoder')
parser.add_argument('--lambda_decorr',
type=float,
default=1,
help='Decorrelation regularization coefficient')
parser.add_argument('--lambda_recons',
type=float,
default=1,
help='Feature reconstruction coefficient for decoder')
parser.add_argument('--decay_lr',
type=float,
default=0.75,
help='Learning rate decay')
parser.add_argument('--seed', type=int, default=1, help='Random seed')
params = parser.parse_args()
# use GPUs
use_cuda = torch.cuda.is_available()
if use_cuda:
device = torch.device('cuda:0')
else:
device = torch.device('cpu')
# fix the random seed
random.seed(params.seed)
torch.manual_seed(params.seed)
torch.cuda.manual_seed_all(params.seed)
# split data
train_index = params.n_train
valid_index = params.n_train + params.n_valid
test_index = params.n_train + params.n_valid + params.n_test
indices_all_imgs = np.arange(test_index)
train_indices = indices_all_imgs[:train_index]
valid_indices = indices_all_imgs[train_index:valid_index]
test_indices = indices_all_imgs[valid_index:test_index]
attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv'
resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/'
train_loader, valid_loader, test_loader = load_data(
attrs_dir, resized_imgs_dir, params.batch_size, train_indices,
valid_indices, test_indices, use_cuda)
# build the model
encoder = Encoder(channel_in=3,
attr_size=params.attr_size,
latent_size=params.latent_size)
decoder = Decoder(z_size=params.attr_size + params.latent_size, size=256)
encoder.apply(weights_init)
decoder.apply(weights_init)
encoder = encoder.to(device)
decoder = decoder.to(device)
# define the optimizers
optim_encoder = optim.RMSprop(encoder.parameters(),
lr=params.lr_encoder,
alpha=0.9)
optim_decoder = optim.RMSprop(decoder.parameters(),
lr=params.lr_decoder,
alpha=0.9)
# schedule learning rate
Steps = [10000, 20000]
lr_scheduler_encoder = MultiStepLR(optim_encoder,
milestones=Steps,
gamma=params.decay_lr)
lr_scheduler_decoder = MultiStepLR(optim_decoder,
milestones=Steps,
gamma=params.decay_lr)
# define several loss functions
attrs_class = nn.BCEWithLogitsLoss().to(device) # attribute classification
decorr_regul = XCov().to(device) # decorrelation regularization
# decorr_regul = dCov2().to(device)
# train the whole model
count_update_step = training(params, encoder, decoder, optim_encoder,
optim_decoder, lr_scheduler_encoder,
lr_scheduler_decoder, device, attrs_class,
decorr_regul, train_loader, valid_loader,
save_dir)
visual_recons(encoder, decoder, device, test_loader)
# save the settings and results
with open(os.path.join(save_dir, 'summary.txt'), 'w') as f:
f.write('Settings and Results:\n')
f.write('------------------------------\n')
f.write('Random seed = ' + str(params.seed) + '\n')
f.write('Image size = ' + str(params.img_sz) + '\n')
f.write('Attribute vector size = ' + str(params.attr_size) + '\n')
f.write('Latent vector size = ' + str(params.latent_size) + '\n')
f.write('Batch size = ' + str(params.batch_size) + '\n')
f.write('------------------------------\n')
f.write('Learning rate of Encoder = ' + str(params.lr_encoder) + '\n')
f.write('Learning rate of Decoder = ' + str(params.lr_decoder) + '\n')
f.write('Learning rate decay = ' + str(params.decay_lr) + '\n')
f.write('------------------------------\n')
f.write('Regularization parameter of the classification term = ' +
str(params.lambda_class) + '\n')
f.write('Regularization parameter of the decorrelation term = ' +
str(params.lambda_decorr) + '\n')
f.write(
'Regularization parameter of the reconstruction term in decoder = '
+ str(params.lambda_recons) + '\n')
f.write('------------------------------\n')
f.write('Training samples = ' + str(params.n_train) + '\n')
f.write('Validation samples = ' + str(params.n_valid) + '\n')
f.write('Test samples = ' + str(params.n_test) + '\n')
f.write('------------------------------\n')
f.write('Max epoch = ' + str(params.n_epochs) + '\n')
f.write('Total update steps = ' + str(count_update_step) + '\n')
def run(args, both_cases=False):
if args.flush_history == 1:
objects = os.listdir(args.log_path)
for f in objects:
if os.path.isdir(args.log_path + f):
shutil.rmtree(args.log_path + f)
now = datetime.now()
logdir = args.log_path + now.strftime("%Y%m%d-%H%M%S") + "/"
os.makedirs(logdir)
log_file = logdir + 'log.txt'
writer = SummaryWriter(logdir)
batch_size = args.batch_size
training_params = {
"batch_size": batch_size,
"shuffle": True,
"num_workers": args.workers,
"drop_last": True
}
validation_params = {
"batch_size": batch_size,
"shuffle": False,
"num_workers": args.workers,
"drop_last": True
}
texts, labels, number_of_classes, sample_weights = load_data(args)
class_names = sorted(list(set(labels)))
class_names = [str(class_name) for class_name in class_names]
train_texts, val_texts, train_labels, val_labels, train_sample_weights, _ = train_test_split(
texts,
labels,
sample_weights,
test_size=args.validation_split,
random_state=42,
stratify=labels)
training_set = MyDataset(train_texts, train_labels, args)
validation_set = MyDataset(val_texts, val_labels, args)
if bool(args.use_sampler):
train_sample_weights = torch.from_numpy(train_sample_weights)
sampler = WeightedRandomSampler(
train_sample_weights.type('torch.DoubleTensor'),
len(train_sample_weights))
training_params['sampler'] = sampler
training_params['shuffle'] = False
training_generator = DataLoader(training_set, **training_params)
validation_generator = DataLoader(validation_set, **validation_params)
model = CharacterLevelCNN(args, number_of_classes)
if torch.cuda.is_available():
model.cuda()
if not bool(args.focal_loss):
if bool(args.class_weights):
class_counts = dict(Counter(train_labels))
m = max(class_counts.values())
for c in class_counts:
class_counts[c] = m / class_counts[c]
weights = []
for k in sorted(class_counts.keys()):
weights.append(class_counts[k])
weights = torch.Tensor(weights)
if torch.cuda.is_available():
weights = weights.cuda()
print(f'passing weights to CrossEntropyLoss : {weights}')
criterion = nn.CrossEntropyLoss(weight=weights)
else:
criterion = nn.CrossEntropyLoss()
else:
if args.alpha is None:
criterion = FocalLoss(gamma=args.gamma, alpha=None)
else:
criterion = FocalLoss(gamma=args.gamma,
alpha=[args.alpha] * number_of_classes)
if args.optimizer == 'sgd':
if args.scheduler == 'clr':
optimizer = torch.optim.SGD(model.parameters(),
lr=1,
momentum=0.9,
weight_decay=0.00001)
else:
optimizer = torch.optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=0.9)
elif args.optimizer == 'adam':
optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
best_f1 = 0
best_epoch = 0
if args.scheduler == 'clr':
stepsize = int(args.stepsize * len(training_generator))
clr = utils.cyclical_lr(stepsize, args.min_lr, args.max_lr)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, [clr])
else:
scheduler = None
for epoch in range(args.epochs):
training_loss, training_accuracy, train_f1 = train(
model, training_generator, optimizer, criterion, epoch, writer,
log_file, scheduler, class_names, args, args.log_every)
validation_loss, validation_accuracy, validation_f1 = evaluate(
model, validation_generator, criterion, epoch, writer, log_file,
args.log_every)
print(
'[Epoch: {} / {}]\ttrain_loss: {:.4f} \ttrain_acc: {:.4f} \tval_loss: {:.4f} \tval_acc: {:.4f}'
.format(epoch + 1, args.epochs, training_loss, training_accuracy,
validation_loss, validation_accuracy))
print("=" * 50)
# learning rate scheduling
if args.scheduler == 'step':
if args.optimizer == 'sgd' and ((epoch + 1) % 3
== 0) and epoch > 0:
current_lr = optimizer.state_dict()['param_groups'][0]['lr']
current_lr /= 2
print('Decreasing learning rate to {0}'.format(current_lr))
for param_group in optimizer.param_groups:
param_group['lr'] = current_lr
# model checkpoint
if validation_f1 > best_f1:
best_f1 = validation_f1
best_epoch = epoch
if args.checkpoint == 1:
torch.save(
model.state_dict(), args.output +
'model_{}_epoch_{}_maxlen_{}_lr_{}_loss_{}_acc_{}_f1_{}.pth'
.format(args.model_name, epoch, args.max_length,
optimizer.state_dict()['param_groups'][0]['lr'],
round(validation_loss, 4),
round(validation_accuracy, 4),
round(validation_f1, 4)))
if bool(args.early_stopping):
if epoch - best_epoch > args.patience > 0:
print(
"Stop training at epoch {}. The lowest loss achieved is {} at epoch {}"
.format(epoch, validation_loss, best_epoch))
break
experiment_results_directory = os.path.abspath(
os.path.join(plotting_dir, dataset, noise_type_str, noise_level_str,
hyperparam_index, init_index))
os.makedirs(experiment_results_directory, exist_ok=True)
model_states_dir = os.path.join(model_dir, noise_type_str, noise_level_str,
hyperparam_index)
run_train, start_epoch, model_to_load = get_train_and_start_epoch(
experiment_results_directory, model_states_dir, epochs,
experiment_name)
if run_train:
# Load data
train_loader, test_loader = load_data(dataset,
batch_size=batch_size,
path=os.path.join(
base_path, '../data'))
if start_epoch == 0:
print("results directory is empty, starting test from beginning")
# create network
torch.manual_seed(seed)
n_in, n_out = get_data_dimensions(dataset)
net = Net(n_in,
n_hidden,
n_out,
n_layer,
act=act,
noise_type=noise_type,
noise_level=noise_level,
args.trained_model_for_prediction))
else:
tokenizer = BertTokenizer.from_pretrained(
args.model_name_or_path, do_lower_case=args.do_lower_case)
logging.info(
"Loaded pretrained model from {} but no fine-tuned tokenizer found, therefore use the standard tokenizer."
.format(args.trained_model_for_prediction))
if args.data_processor == "QqpProcessor":
processor = QqpProcessor()
else:
# this is the default as it works for all data sets of the deepmatcher project.
processor = DeepMatcherProcessor()
test_examples = processor.get_test_examples(args.data_path)
logging.info("loaded {} test examples".format(len(test_examples)))
test_data_loader = load_data(test_examples, processor.get_labels(),
tokenizer, args.max_seq_length,
args.test_batch_size, DataType.TEST)
simple_accuracy, f1, classification_report, predictions = predict(
model, device, test_data_loader)
logging.info(
"Prediction done for {} examples.F1: {}, Simple Accuracy: {}".format(
len(test_data_loader), f1, simple_accuracy))
logging.info(classification_report)
logging.info(predictions)
else:
device = torch.device('cpu')
net = VaeGan(device=device, z_size=z_size, recon_level=recon_level).to(device)
# DATASET
train_index = n_train
valid_index = n_train + n_valid
test_index = n_train + n_valid + n_test
indices_all_imgs = np.arange(test_index)
train_indices = indices_all_imgs[:train_index]
valid_indices = indices_all_imgs[train_index:valid_index]
test_indices = indices_all_imgs[valid_index:test_index]
attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv'
resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/'
dataloader, dataloader_valid, dataloader_test = load_data(attrs_dir, resized_imgs_dir, batch_size,
train_indices, valid_indices, test_indices, args)
# margin and equilibirum
margin = 0.35
equilibrium = 0.68
# OPTIM-LOSS
optimizer_encoder = optim.RMSprop(params=net.encoder.parameters(), lr=lr,
alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False)
optimizer_decoder = optim.RMSprop(params=net.decoder.parameters(), lr=lr,
alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False)
optimizer_discriminator = optim.RMSprop(params=net.discriminator.parameters(), lr=lr,
alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False)
Steps = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000]
lr_encoder = MultiStepLR(optimizer_encoder, milestones=Steps, gamma=decay_lr)
new.save(file_path)
def clear(self):
self.image.fill(Qt.white)
self.update()
def guess(self):
# Obtener imagen
image = self.image.scaled(28, 28) # Scale image
n = loader.qimage_to_ndarray(image)
drawing, percentage = self.network.evaluate_drawing(n)
message = ("I'm %s%% sure it's a %s!" %
(int(percentage[0]), loader.image_classifier(int(drawing))))
QMessageBox.about(self, "Result", message)
if __name__ == '__main__':
# Load Data
train, cv, test = loader.load_data(11000)
# Create neural network
net = network.Network([784, 100, 10])
# training_data, test, cv epochs, batch_size, learning, lambda
net.train(train, test, cv, 8, 20, 0.4, 10)
app = QApplication(sys.argv)
window = Window(net)
window.show()
app.exec()
logging.info("training with {} labels: {}".format(len(label_list), label_list))
config_class, model_class, tokenizer_class = Config.MODEL_CLASSES[args.model_type]
config = config_class.from_pretrained(args.model_name_or_path)
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path, do_lower_case=args.do_lower_case)
model = model_class.from_pretrained(args.model_name_or_path, config=config)
model.to(device)
logging.info("initialized {}-model".format(args.model_type))
train_examples = processor.get_train_examples(args.data_path)
training_data_loader = load_data(train_examples,
label_list,
tokenizer,
args.max_seq_length,
args.train_batch_size,
DataType.TRAINING, args.model_type)
logging.info("loaded {} training examples".format(len(train_examples)))
num_train_steps = len(training_data_loader) * args.num_epochs
optimizer, scheduler = build_optimizer(model,
num_train_steps,
args.learning_rate,
args.adam_eps,
args.warmup_steps,
args.weight_decay)
logging.info("Built optimizer: {}".format(optimizer))
eval_examples = processor.get_test_examples(args.data_path)
def get_sensitivity_data_loader(dataset,
classes,
data_path,
num_interpolations,
re_generate=False):
if not isinstance(classes, list):
raise ValueError("Classes must be a list of integers")
elif not isinstance(classes[0], int):
raise ValueError("Classes must be a list of integers")
train_loader, _ = load_data(dataset, path=data_path, batch_size=None)
data = None
lables = None
# put code in here to calculate means and store all sorted classes?
for batch, target in train_loader:
image_shape = batch.shape[1:]
data = batch.view(batch.shape[0], -1)
labels = target
if re_generate:
print("regenerate data")
sorted_data = {i: data[labels == i] for i in range(10)}
means = {i: sorted_data[i].mean(dim=0) for i in range(10)}
############################################################################
# dist = np.linalg.norm((data[:, :, np.newaxis] - means), axis=1)
############################################################################
for i in range(10):
# find data point for each class that is closest to the mean (order them?)
images = sorted_data[i]
mean = means[i].unsqueeze(0)
difference = images - mean
distances = torch.norm(difference, dim=-1)
order = np.argsort(distances)
sorted_data[i] = sorted_data[i][order]
data_points = [
sorted_data[_class][0].numpy()
for index, _class in enumerate(classes)
]
else:
data_points = None
# plot_means_data_points([means[c] for c in classes], data_points, image_shape)
st = SensitivityTest(root=data_path,
data_points=data_points,
classes=classes,
re_generate=re_generate,
num_interpolations=num_interpolations,
transform=transforms.ToTensor(),
image_shape=image_shape)
# plot_targets(st.targets, classes)
return torch.utils.data.DataLoader(dataset=st, batch_size=1, shuffle=False)
if __name__ == '__main__':
# use GPU if available
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print(device)
# set seed
seed = 1
torch.manual_seed(seed)
# set hyperparameters
n_in = 784
n_hidden = 100
n_out = 10
n_layer = 10
n_epochs = 20
train_loader, test_loader = load_data('mnist')
eval_epochs = np.arange(0, n_epochs)
eval_epochs = [0, 3, 8, 13, 19]
n_iterations = 5
Y1 = get_score(n_iterations, 2, 'init_2', n_epochs, eval_epochs,
train_loader, test_loader, device)
Y2 = get_score(n_iterations, 1, 'init_1', n_epochs, eval_epochs,
train_loader, test_loader, device)
X = np.array(eval_epochs)
plot_average(X, [Y1, Y2], ['Optimal Init', 'Suboptimal Init'], ['g', 'r'])
import os
import sys
import torch.nn as nn
import numpy as np
# custom import
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
from src.data_loader import load_data
from src.utils import get_experiment_dicts, test_models, load_model_results
# Load MNIST data
train_loader, test_loader = load_data('mnist', path='../data')
# Load models
result_path = '../results'
model_dicts = get_experiment_dicts(result_path)
# Test models
dump_path = '../plotting'
criterion = nn.CrossEntropyLoss()
test_models(model_dicts,
criterion,
train_loader,
test_loader,
result_path=result_path,
dump_path=dump_path,
quiet=True)
def run(args):
batch_size = args.batch_size
training_params = {"batch_size": batch_size,
"shuffle": True,
"num_workers": args.workers}
texts, labels, number_of_classes, sample_weights = load_data(args)
train_texts, _, train_labels, _, _, _ = train_test_split(texts,
labels,
sample_weights,
test_size=args.validation_split,
random_state=42,
stratify=labels)
training_set = MyDataset(train_texts, train_labels, args)
training_generator = DataLoader(training_set, **training_params)
model = CharacterLevelCNN(args, number_of_classes)
if torch.cuda.is_available():
model.cuda()
model.train()
criterion = nn.CrossEntropyLoss()
if args.optimizer == 'sgd':
optimizer = torch.optim.SGD(
model.parameters(), lr=args.start_lr, momentum=0.9
)
elif args.optimizer == 'adam':
optimizer = torch.optim.Adam(
model.parameters(), lr=args.start_lr
)
start_lr = args.start_lr
end_lr = args.end_lr
lr_find_epochs = args.epochs
smoothing = args.smoothing
def lr_lambda(x): return math.exp(
x * math.log(end_lr / start_lr) / (lr_find_epochs * len(training_generator)))
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
losses = []
learning_rates = []
for epoch in range(lr_find_epochs):
print(f'[epoch {epoch + 1} / {lr_find_epochs}]')
progress_bar = tqdm(enumerate(training_generator),
total=len(training_generator))
for iter, batch in progress_bar:
features, labels = batch
if torch.cuda.is_available():
features = features.cuda()
labels = labels.cuda()
optimizer.zero_grad()
predictions = model(features)
loss = criterion(predictions, labels)
loss.backward()
optimizer.step()
scheduler.step()
lr = optimizer.state_dict()["param_groups"][0]["lr"]
learning_rates.append(lr)
if iter == 0:
losses.append(loss.item())
else:
loss = smoothing * loss.item() + (1 - smoothing) * losses[-1]
losses.append(loss)
plt.semilogx(learning_rates, losses)
plt.savefig('./plots/losses_vs_lr.png')
from src.data_loader import load_data
from src.model2 import Network
from tqdm import tqdm
import random
def random_combination(iterable, r):
"Random selection from itertools.combinations(iterable, r)"
pool = tuple(iterable)
n = len(pool)
indices = sorted(random.sample(range(n), r))
return tuple(pool[i] for i in indices)
if __name__ == '__main__':
num_works, num_shifts, min_num_shifts, shifts = load_data(filename='r1')
n = Network(num_works, num_shifts, shifts)
n.create_init_solution(use_heuristic=True)
it = 0
clusters_id = [i for i in range(len(n.clusters))]
while True:
# for i in range(1):
# random_order = random_combination(clusters_id, len(clusters_id))
# for i in random_order:
# n.repair(updated_cluster_id=i)
# n.clusters[i].repair()
for i in range(len(n.clusters)):
# n.repair(updated_cluster_id=i)
random.seed(params.seed)
torch.manual_seed(params.seed)
torch.cuda.manual_seed_all(params.seed)
# split data
train_index = params.n_train
valid_index = params.n_train + params.n_valid
test_index = params.n_train + params.n_valid + params.n_test
indices_all_imgs = np.arange(test_index)
train_indices = indices_all_imgs[:train_index]
valid_indices = indices_all_imgs[train_index:valid_index]
test_indices = indices_all_imgs[valid_index:test_index]
attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv'
resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/'
train_loader, valid_loader, test_loader = load_data(
attrs_dir, resized_imgs_dir, params.batch_size, train_indices,
valid_indices, test_indices, use_cuda)
# build the model
cgan = cGAN(params, device)
encoder_z = EncoderZ(params.input_channel_dis, params.dim_z)
encoder_y = EncoderY(params.input_channel_dis, params.class_num)
cgan.apply(weights_init)
encoder_z.apply(weights_init)
encoder_y.apply(weights_init)
cgan = cgan.to(device)
encoder_z = encoder_z.to(device)
encoder_y = encoder_y.to(device)
# define optimizers
optim_gen = optim.Adam(cgan.Gen.parameters(),
parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs')
parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop')
parser.add_argument('--item_update_mode', type=str, default='plus_transform',
help='how to update item at the end of each hop')
parser.add_argument('--using_all_hops', type=bool, default=True,
help='whether using outputs of all hops or just the last hop when making prediction')
'''
# default settings for Book-Crossing
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', type=str, default='book', help='which dataset to use')
parser.add_argument('--dim', type=int, default=4, help='dimension of entity and relation embeddings')
parser.add_argument('--n_hop', type=int, default=2, help='maximum hops')
parser.add_argument('--kge_weight', type=float, default=1e-2, help='weight of the KGE term')
parser.add_argument('--l2_weight', type=float, default=1e-5, help='weight of the l2 regularization term')
parser.add_argument('--lr', type=float, default=1e-3, help='learning rate')
parser.add_argument('--batch_size', type=int, default=1024, help='batch size')
parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs')
parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop')
parser.add_argument('--item_update_mode', type=str, default='plus_transform',
help='how to update item at the end of each hop')
parser.add_argument('--using_all_hops', type=bool, default=True,
help='whether using outputs of all hops or just the last hop when making prediction')
'''
args = parser.parse_args()
show_loss = False
data_info = load_data(args)
train(args, data_info, show_loss)