def __init__(self,
obs_dim,
latent_dim,
hidden_dim=600,
bidirectional=True,
num_layers=2,
min_var=1e-4,
dropout_ratio=args.dropout):
super(StateEncoder, self).__init__()
self.obs_dim = obs_dim
self.latent_dim = latent_dim
self.hidden_dim = hidden_dim
if bidirectional:
print("Using Bidir in EncoderLSTM")
self.num_directions = 2 if bidirectional else 1
self.num_layers = num_layers
self.lstm = nn.LSTM(obs_dim,
hidden_dim // self.num_directions,
self.num_layers,
batch_first=True,
dropout=dropout_ratio,
bidirectional=bidirectional)
self.attention_layer = model.SoftDotAttention(hidden_dim, obs_dim)
self.post_lstm = nn.LSTM(hidden_dim,
hidden_dim // self.num_directions,
self.num_layers,
batch_first=True,
dropout=dropout_ratio,
bidirectional=bidirectional)
self.mean_network = model.MLP(hidden_dim, latent_dim)
self.log_var_network = model.MLP(hidden_dim, latent_dim)
# self.min_log_var = Variable(np.log(np.array([min_var])).astype(np.float32))
self.min_log_var = torch.from_numpy(
np.log(np.array([min_var])).astype(np.float32)).cuda()
def gen_models():
name1 = "10category_top3acc"
model_name1 = "MLP"
total_name1 = model_name1 + "_" + name1
name2 = "8category_top3acc_extend"
model_name2 = "MLP1"
total_name2 = model_name2 + "_" + name2
with tf.name_scope(model_name1) as scope1:
sess1 = tf.Session()
model1 = mod.MLP(name=model_name1,
sess=sess1,
scope=scope1,
output_dim=10,
input_dim=10)
model1.init2()
saver1 = tf.train.Saver(model1.var)
save_path = abs_path + "/save/" + total_name1 + "/" + total_name1 + ".ckpt"
saver1.restore(sess1, save_path=save_path)
with tf.name_scope(model_name2) as scope2:
sess2 = tf.Session()
model2 = mod.MLP(name=model_name2,
sess=sess2,
scope=scope2,
output_dim=8,
input_dim=5)
model2.init2()
saver2 = tf.train.Saver(model2.var)
save_path1 = abs_path + "/save/" + total_name2 + "/" + total_name2 + ".ckpt"
saver2.restore(sess2, save_path=save_path1)
return sess1, model1, sess2, model2
def train(self, dataX, dataY):
data = dataset.MLPOnlineDataset(dataX=dataX, dataY=dataY)
self.model_lstm = model.MLP(input_size=3, output_size=1)
self.experiment = Experiment(config=self.config,
model=self.model_lstm,
dataset=data)
self.experiment.run()
def cross_validation(args):
for iter in range(1, args.num_models + 1):
args.lr = 10**np.random.uniform(-5, -1)
args.weight_decay = 10**np.random.uniform(-5, 1)
if args.modeltype in ['LR', 'MLP']:
args.factor = np.random.randint(90, 111)
model = models.LR(args) if args.modeltype == 'LR'\
else models.MLP(args)
print('{}, Model: {}, lr: {:.5f}, wd: {:.5f}, factor: {}'.format(
iter, args.modeltype, args.lr, args.weight_decay, args.factor))
f = open(args.filepath, 'a')
f.write('%d, Model: %s, lr: %.5f, wd: %.5f, factor: %d\n' %
(iter, args.modeltype, args.lr, args.weight_decay,
args.factor))
f.close()
elif args.modeltype in ['CNN', 'CNNDeep']:
args.embed_dim = np.random.randint(90, 111)
args.kernel_num = np.random.randint(90, 111)
args.dropout = np.random.uniform(0.1, 0.5)
model = models.CNN(args) if args.modeltype == 'CNN'\
else models.CNNDeep(args)
print('{}, Model: {}, lr: {:.5f}, wd: {:.5f}, embed_dim: {},\
kernel_num: {}, dropout: {:.5f}'.format(
iter, args.modeltype, args.lr, args.weight_decay,
args.embed_dim, args.kernel_num, args.dropout))
f = open(args.filepath, 'a')
f.write('%d, Model: %s, lr: %.5f, wd: %.5f, embed_dim: %d,\
kernel_num: %d, dropout: %.5f\n' %
(iter, args.modeltype, args.lr, args.weight_decay,
args.embed_dim, args.kernel_num, args.dropout))
f.close()
train_and_evaluate(args, model)
def __init__(self,
obs_dim,
latent_dim,
view_num,
path_len=2,
hidden_dim=256,
bidirectional=False,
num_layers=1,
dropout_ratio=args.dropout):
super(StateDecoder, self).__init__()
self.obs_dim = obs_dim
self.latent_dim = latent_dim
self.path_len = path_len
self.hidden_dim = hidden_dim
self.num_directions = 2 if bidirectional else 1
self.num_layers = num_layers
self.view_num = view_num
self.view_atten = model.SelfAttention(obs_dim + latent_dim, hidden_dim)
self.fc1 = nn.Linear(obs_dim + latent_dim, hidden_dim)
self.relu1 = nn.LeakyReLU()
self.h_size = 1
if bidirectional:
self.h_size += 1
self.h_size *= num_layers
self.lstm = nn.LSTM(hidden_dim,
hidden_dim,
num_layers,
batch_first=True,
dropout=dropout_ratio,
bidirectional=bidirectional)
self.mean_network = model.MLP(hidden_dim, obs_dim * view_num)
self.log_var_network = model.Parameter(obs_dim * view_num,
init=np.log(0.1))
def load_checkpoint(self, ckpt):
if os.path.isfile(ckpt):
ckpt = torch.load(ckpt, map_location=lambda storage, loc: storage)
# Load model state
if self.model.input_size != ckpt[
'input_size'] or self.model.n_hidden != ckpt[
'n_hidden'] or self.model.hidden_size != ckpt[
'hidden_size'] or self.model.dropout_prob != ckpt[
'dropout_prob']:
print('Reinstantiating model with correct configuration')
self.model = model_.MLP(n_in=ckpt['input_size'],
nh=ckpt['n_hidden'],
n_h=ckpt['hidden_size'],
dropout_prob=ckpt['dropout_prob'])
print(self.model)
self.model.load_state_dict(ckpt['model_state'])
# Load optimizer state
self.optimizer.load_state_dict(ckpt['optimizer_state'])
# Load history
self.history = ckpt['history']
self.total_iters = ckpt['total_iters']
self.cur_epoch = ckpt['cur_epoch']
if self.cuda_mode:
self.model = self.model.to(self.device)
else:
print('No checkpoint found at: {}'.format(ckpt))
def set_model(model_file, args):
# Define the Model
print(args.xvars)
args.region = args.data_region
# in_features = (args.nlevs*(len(args.xvars)-3)+3)
# if not args.train_on_y2:
# nb_classes = (args.nlevs*(len(args.yvars)))
# else:
# nb_classes = (args.nlevs*(len(args.yvars2)))
in_features = args.in_features
nb_classes = args.nb_classes
hidden_size = args.hidden_size
# n_inputs,n_outputs=140,70
# in_features, nb_classes=(args.nlevs*4+3),(args.nlevs*2)
# hidden_size = int(1. * in_features + nb_classes)
mlp = nn_model.MLP(in_features, nb_classes, args.nb_hidden_layers,
hidden_size)
# mlp = nn_model.MLPSkip(in_features, nb_classes, args.nb_hidden_layers, hidden_size)
# mlp = nn_model.MLPDrop(in_features, nb_classes, args.nb_hidden_layers, hidden_size)
# Load the save model
print("Loading PyTorch model: {0}".format(model_file))
checkpoint = torch.load(model_file, map_location=torch.device('cpu'))
mlp.load_state_dict(checkpoint['model_state_dict'])
mlp.eval()
print("Model's state_dict:")
for param_tensor in mlp.state_dict():
print(param_tensor, "\t", mlp.state_dict()[param_tensor].size())
return mlp
def test():
covs = return_covs()
with tf.name_scope("hellokugou") as scope:
if not os.path.exists("models/hellokugou"):
os.mkdir("models/hellokugou")
sess = tf.Session()
model = mod.MLP(name="hellokugou",
sess=sess,
scope=scope,
output_dim=10)
train_data, train_label, test_data, test_label, test_data_ = prepare_data(
10, gen_label=True, static_box=True, covs=covs)
model.init1(train_data, train_label, test_data, test_label)
ac = []
# for i in range(0, 20):
acc, y_, output_label, ground_truth_label, out_pro = model.run1(
name="with_genre")
ac.append(acc)
total = np.asarray(
np.concatenate(
(test_data_, np.asmatrix(ground_truth_label).transpose(),
np.asmatrix(output_label).transpose(), y_), 1))
print(total)
print(acc)
print(np.mean(ac))
def restore():
with tf.name_scope("hellokugou") as scope:
covs = return_covs()
sess = tf.Session()
model = mod.MLP(name="hellokugou",
sess=sess,
scope=scope,
output_dim=10)
train_data, train_label, test_data, test_label, test_data_ = prepare_data(
10, gen_label=True, static_box=True, covs=covs)
model.init1(train_data, train_label, test_data, test_label)
acc, y_, output_label, ground_truth_label, out_pro = model.run1(
name="with_genre", steps=1, is_save=True)
scaler = pre.MinMaxScaler()
out_pro = np.asarray(out_pro, dtype=np.float32).transpose()
out_pro = scaler.fit_transform(out_pro).transpose()
sums = np.asmatrix(np.sum(out_pro, axis=1))
out_pro = out_pro / sums.transpose()
total = np.asarray(
np.concatenate(
(test_data_, np.asmatrix(ground_truth_label).transpose(),
np.asmatrix(output_label).transpose(),
np.asmatrix(out_pro, dtype=np.float32)), 1))
print(total)
print(acc)
# print(out_pro)
# print(np.sum(out_pro, axis=1))
return total, out_pro
def set_model(args):
mlp = model.MLP(args.in_features, args.nb_classes, args.nb_hidden_layers,
args.hidden_size)
# mlp = model.MLP_BN(in_features, nb_classes, nb_hidden_layer, hidden_size)
pytorch_total_params = sum(p.numel() for p in mlp.parameters()
if p.requires_grad)
print("Number of traninable parameter: {0}".format(pytorch_total_params))
if args.loss == "mae":
loss_function = torch.nn.functional.l1_loss #torch.nn.L1Loss()
elif args.loss == "mse":
loss_function = torch.nn.functional.mse_loss #torch.nn.MSELoss()
elif args.loss == "mink":
loss_function = minkowski_error
optimizer, scheduler = configure_optimizers(mlp)
if args.warm_start:
# Load the save model
checkpoint = torch.load(args.locations['model_loc'] + '/' +
args.model_name,
map_location=args.device)
mlp.load_state_dict(checkpoint['model_state_dict'])
mlp.to(args.device)
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
loss = checkpoint['loss']
epoch = checkpoint['epoch']
args.model_name = args.model_name.replace(
'.tar', '_{0}.tar'.format(args.region))
else:
mlp.to(args.device)
print("Model's state_dict:")
for param_tensor in mlp.state_dict():
print(param_tensor, "\t", mlp.state_dict()[param_tensor].size())
return mlp, loss_function, optimizer, scheduler
def train(self,dataN):
dataY = dataN[self.filterSize:]#self.dataToClassFunc(dataN[self.filterSize:], self.thresholding)
dataX = self.featureExtraction(dataN)
data = dataset.MLPOnlineDataset(dataX=dataX, dataY=dataY)
self.model_mlp = model.MLP(input_size=40, output_size=1)
self.experiment = Experiment(config=self.config, model=self.model_mlp, dataset=data)
self.experiment.run()
def load_npz_file_to_model(npz_filename='model.npz'):
# Create model object first
model1 = model.MLP()
# Load the saved parameters into the model object
chainer.serializers.load_npz(npz_filename, model1)
print('{} loaded!'.format(npz_filename))
return model1
def load_hdf5_file_to_model(hdf5_filename='model.h5'):
# Create another model object first
model2 = model.MLP()
# Load the saved parameters into the model object
chainer.serializers.load_hdf5(hdf5_filename, model2)
print('{} loaded!'.format(hdf5_filename))
return model2
def test():
dataset = data_tool.load(file_path)
word2id = dataset["dict"]
embedding = nn.Embedding(len(word2id), gru_hidden_size)
embedding.load_state_dict(embedding_sd)
gru = model.BiGRU(gru_hidden_size, embedding, gru_n_layers)
gru.load_state_dict(gru_sd)
ffnn = model.MLP(gru_hidden_size * ffnn_init_num * 2, ffnn_hidden_size, 2,
ffnn_n_layers)
ffnn.load_state_dict(ffnn_sd)
gru = gru.to(device)
ffnn = ffnn.to(device)
gru.eval()
ffnn.eval()
ref_src = doc2ID(os.path.join(args.reference, "ref.utr"), word2id)
ref_tgt = doc2ID(os.path.join(args.reference, "ref.rep"), word2id)
for i in trange(len(ref_src), ncols=0):
hyp_src = doc2ID(
os.path.join(args.hypothesis, "candidate_" + str(i) + "_utr.txt"),
word2id)
hyp_tgt = doc2ID(
os.path.join(args.hypothesis, "candidate_" + str(i) + "_rpl.txt"),
word2id)
input_var = []
input_var.append([ref_src[i] for _ in hyp_src])
input_var.append([ref_tgt[i] for _ in hyp_src])
input_var.append(hyp_src)
input_var.append(hyp_tgt)
input_var = [inputs for inputs in zip(*input_var)]
dummy_label = [1] * len(input_var)
pres = []
probs = []
data_iterator = data_tool.iterator(input_var,
dummy_label,
batch_size,
random=False)
for data, length, _ in data_iterator:
with torch.no_grad():
data = data_tool.padding(data)
predictions, probability = modelAll(data, length, gru, ffnn,
embedding)
pres += [int(label) for label in predictions]
probs += [float(prob) for prob in probability[0].cpu()]
with open(
os.path.join(args.save_dir,
"candidate_" + str(i) + "_predictions.txt"),
"w") as f:
for label, prob in zip(pres, probs):
f.write(str((label - 0.5) * 2 * (prob - 0.5) * 2) + "\r\n")
def final_run(args):
if args.modeltype == 'LR':
model = models.LR(args)
elif args.modeltype == 'MLP':
model = models.MLP(args)
elif args.modeltype == 'CNN':
model = models.CNN(args)
elif args.modeltype == 'CNNDeep':
model = models.CNNDeep(args)
train_and_evaluate(args, model)
def train(self,dataN):
dataY = dataN[self.filterSize:]
dataX = self.featureExtraction(dataN)
print("dataX",dataX.shape)
print("dataY",dataY.shape)
data = dataset.MLPOnlineDataset(dataX=dataX, dataY=dataY)
self.model_mlp = model.MLP(input_size=11, output_size=1)
self.experiment = Experiment(config=self.config, model=self.model_mlp, dataset=data)
self.experiment.run()
def init_model(model_type):
model = []
if model_type == 'LeNet5':
model = fedmodel.LeNet5()
elif model_type == 'MLP':
model = fedmodel.MLP()
elif model_type == 'ResNet18':
model = fedmodel.ResNet18()
elif model_type == 'CNN':
model = fedmodel.CNN()
return model
def main():
# if gpu is to be used
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# data object
data = dl.Dataset(DATA_OPTIONS, device)
# Pytorch model
mlp = model.MLP()
print('hi')
def restore_model():
save_path = os.path.normpath('%s/%s' % (abs_path, 'save/hellokugou_'))
with tf.name_scope("hellokugou") as scope:
sess = tf.Session()
model = mod.MLP(name="hellokugou",
sess=sess,
scope=scope,
output_dim=10,
input_dim=10)
model.init2()
saver = tf.train.Saver()
name = "with_genre"
saver.restore(sess, save_path=save_path + name + ".ckpt")
return sess, model
def inference():
thandler = trainer.handler(args.process_command())
rt_data = rt()
data = trainer.load_data(rt_data.data, data_type=rt_data.data_type)
test_loader = data
model_ = models.MLP(300, classes=2)
#print(model_)
total = sum(p.numel() for p in model_.parameters() if p.requires_grad)
print('# of para: {}'.format(total))
model_name = 'MLP.pt'
predicted = thandler.predict(model_, test_loader, model_name)
print([np.argmax(np.array(i)) for i in predicted])
def main():
print()
examples_train, examples_test = dataset.Read_Data("./data/" + pb.source +
".csv")
pb.LABELS = sorted(set([example.label for example in examples_train]))
print(pb.source, pb.LABELS, len(examples_train), len(examples_test))
textEmd = representation.Representator(examples_train)
data_filepath = "./data/" + pb.source + "_bert"
if (os.path.exists(data_filepath) == True):
[examples_train, examples_test] = pb.Pickle_Read(data_filepath)
textEmd.Get_Representations(examples_train)
textEmd.Get_Representations(examples_test)
# pb.Pickle_Save([examples_train, examples_test], data_filepath)
textEmd.Get_nGram_Representations(examples_train)
textEmd.Get_nGram_Representations(examples_test)
# pb.Pickle_Save([examples_train, examples_test], data_filepath)
examples_train = dataset.Get_Balanced_Data(examples_train)
xs_train, gs_train, ys_train = dataset.Get_Encoded_Data(examples_train)
xs_test, gs_test, ys_test = dataset.Get_Encoded_Data(examples_test)
# from sklearn import svm
# clf = svm.SVC()
# clf.fit(xs_train, ys_train)
# pre_labels = clf.predict(xs_test)
# recall, precision, macrof1, microf1, acc = pb.Get_Report(ys_test, pre_labels, pb.LABELS, 2)
# print("recall:{:.4%} precision:{:.4%} macrof1:{:.4%} microf1:{:.4%}".format(recall, precision, macrof1, microf1))
print()
mlp_model = model.MLP(xs_train, gs_train)
rep_width, add_width, best_ma, best_mi = mlp_model.train(
xs_train, gs_train, ys_train, xs_test, gs_test, ys_test)
return rep_width, add_width, best_ma, best_mi
def main():
trainX, trainY, testX, testY = load_mnist()
print("Shapes: ", trainX.shape, trainY.shape, testX.shape, testY.shape)
epochs = 25
num_hidden_units = 300
minibatch_size = 100
regularization_rate = 0.01
learning_rate = 0.001
model = model.MLP(num_hidden_units, minibatch_size, regularization_rate, learning_rate)
print("Starting training..........")
model.train(trainX, trainY, epochs)
print("Training complete")
print("Starting testing..........")
labels = model.test(testX)
accuracy = np.mean((labels == testY)) * 100.0
print("\nTest accuracy: %lf%%" % accuracy)
def startTrain(self):
train, label, test, test_label, max = data_model.loadDataset(
self.filename)
mlp = model.MLP(float(self.lrEntry.get()), len(train[0]),
int(self.hiddenEntry.get()),
int(self.layerEntry.get()), label[0].shape[1])
for epoch in range(int(self.conditionEntry.get())):
random_index = np.arange(len(train))
np.random.shuffle(random_index)
for i in range(len(train)):
index = random_index[i]
mlp.forward(train[index])
mlp.backpropagate(label[index])
tp = mlp.precision(train, label)
rmse = mlp.rmse(train, label)
self.train = train
self.label = label
self.test = test
self.test_label = test_label
self.messagebox.insert(END, '#')
self.messagebox.insert(END, self.count)
self.messagebox.insert(END, '\n')
self.messagebox.insert(END, 'Train Precision: ')
self.messagebox.insert(END, tp)
self.messagebox.insert(END, '\n')
if not test == []:
rmse = mlp.rmse(train, label)
p = mlp.precision(test, test_label)
self.messagebox.insert(END, 'Test Precision: ')
self.messagebox.insert(END, p)
self.messagebox.insert(END, '\n')
self.messagebox.insert(END, 'RMSE value: ')
self.messagebox.insert(END, rmse)
self.messagebox.insert(END, '\n')
self.mlp = mlp
self.count += 1
def main(args):
# seed ##############
np.random.seed(2020)
torch.manual_seed(1)
# dataset ##########################################
if args.dataset == "mnist":
args.data_path = args.data_path + "mnist/"
if not os.path.exists(args.data_path):
os.makedirs(args.data_path)
test_set = datasets.MNIST(args.data_path, train=False,
download=True,
transform=transforms.Compose([
transforms.Resize([32, 32]),
transforms.ToTensor()]))
test_loader = torch.utils.data.DataLoader(
test_set,
num_workers=32,
batch_size=args.test_size
)
elif args.dataset == "shape":
test_set = utils.ShapeDataset(data_size=args.test_size)
test_set.set_seed(2020)
test_loader = torch.utils.data.DataLoader(
test_set,
shuffle=True,
num_workers=32,
batch_size=args.test_size
)
elif args.dataset == "celeba":
test_set = utils.ImageFolder(
args.data_path + '/test/',
transform=transforms.Compose([transforms.CenterCrop(148),
transforms.Resize([64, 64]),
transforms.ToTensor()]))
test_loader = torch.utils.data.DataLoader(
test_set,
num_workers=32,
batch_size=args.test_size
)
# load model ##########################################
if args.dataset == "mnist":
if args.vae:
enc = model.MNIST_Encoder(args.n * 2)
dec = model.MNIST_Decoder(args.n, vae=True)
else:
enc = model.MNIST_Encoder(args.n)
dec = model.MNIST_Decoder(args.n)
elif args.dataset == "celeba":
if args.vae:
enc = model.CelebA_Encoder(args.n * 2)
dec = model.CelebA_Decoder(args.n, vae=True)
else:
enc = model.CelebA_Encoder(args.n)
dec = model.CelebA_Decoder(args.n)
elif args.dataset == "shape":
if args.vae:
enc = model.Shape_Encoder(args.n * 2)
dec = model.Shape_Decoder(args.n, vae=True)
else:
enc = model.Shape_Encoder(args.n)
dec = model.Shape_Decoder(args.n)
dec.load_state_dict(torch.load(
args.checkpoint + "/" + args.dataset + "/dec_" + args.model_name,
map_location=torch.device('cpu')))
enc.load_state_dict(torch.load(
args.checkpoint + "/" + args.dataset + "/enc_" + args.model_name,
map_location=torch.device('cpu')))
dec.eval()
enc.eval()
if args.l > 0:
mlp = model.MLP(args.n, args.l)
mlp.load_state_dict(torch.load(
args.checkpoint + "/" + args.dataset +
"/mlp_" + args.model_name,
map_location=torch.device('cpu')))
mlp.eval()
#####################################################
fig, axs = plt.subplots(args.X, args.Y, figsize=[args.Y, args.X])
if args.task == "reconstruction":
yi, _ = next(iter(test_loader))
if args.vae:
z_hat = enc(yi)
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
zi = model.reparametrization(mu, logvar)
else:
if args.l > 0:
zi = mlp(enc(yi))
else:
zi = enc(yi)
y_hat = dec(zi[:args.X * args.Y]).data.numpy()
elif args.task == "interpolation":
yi, _ = next(iter(test_loader))
if args.vae:
z_hat = enc(yi)
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
zi = model.reparametrization(mu, logvar)
else:
if args.l > 0:
zi = mlp(enc(yi))
else:
zi = enc(yi)
zs = []
for i in range(args.X):
z0 = zi[i*2]
z1 = zi[i*2+1]
for j in range(args.Y):
zs.append((z0 - z1) * j / args.Y + z1)
zs = torch.stack(zs, axis=0)
y_hat = dec(zs).data.numpy()
elif args.task == "mvg":
z = []
for yi, _ in test_loader:
if args.vae:
z_hat = enc(yi)
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
zi = model.reparametrization(mu, logvar)
else:
if args.l > 0:
zi = mlp(enc(yi))
else:
zi = enc(yi)
z.append(zi.detach().numpy())
z = np.concatenate(z, axis=0)
mu = np.average(z, axis=0)
sigma = np.cov(z, rowvar=False)
# generate corresponding sample z
zs = np.random.multivariate_normal(mu, sigma, args.X * args.Y)
zs = torch.Tensor(zs)
y_hat = dec(zs).data.numpy()
elif args.task == "gmm":
z = []
for yi, _ in test_loader:
if args.vae:
z_hat = enc(yi)
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
zi = model.reparametrization(mu, logvar)
else:
if args.l > 0:
zi = mlp(enc(yi))
else:
zi = enc(yi)
z.append(zi.detach().numpy())
z = np.concatenate(z, axis=0)
gmm = mixture.GaussianMixture(
n_components=args.d, covariance_type='full')
gmm.fit(z)
zs, _ = gmm.sample(args.X * args.Y)
zs = torch.Tensor(zs)
y_hat = dec(zs).data.numpy()
elif args.task == "pca":
z = []
for yi, _ in test_loader:
if args.vae:
z_hat = enc(yi)
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
zi = model.reparametrization(mu, logvar)
else:
if args.l > 0:
zi = mlp(enc(yi))
else:
zi = enc(yi)
z.append(zi.detach().numpy())
z = np.concatenate(z, axis=0)
pca = PCA(n_components=args.d)
pca.fit(z)
x = pca.transform(z)
mu = np.average(x, axis=0)
sigma = np.cov(x, rowvar=False)
sigma_0 = np.sqrt(sigma[0][0])
sigma_1 = np.sqrt(sigma[1][1])
center = mu.copy()
center[0] -= sigma_0 * 2
center[1] -= sigma_1 * 2
zs = []
for i in range(args.X):
tmp = []
x = center.copy()
x[0] += sigma_0 * i / args.X * 4
for j in range(args.Y):
x[1] += sigma_1 / args.Y * 4
zi = pca.inverse_transform(x)
tmp.append(zi)
tmp = np.stack(tmp, axis=0)
zs.append(tmp)
zs = np.concatenate(zs, axis=0)
zs = torch.Tensor(zs)
y_hat = dec(zs).data.numpy()
# now plot
for i in range(args.X):
for j in range(args.Y):
if args.dataset == 'mnist':
im = y_hat[i*args.Y+j][0, :, :]
else:
im = np.transpose(y_hat[i*args.Y+j], [1, 2, 0])
if args.dataset == 'mnist':
axs[i, j].imshow(1-im, interpolation='nearest', cmap='Greys')
else:
axs[i, j].imshow(im, interpolation='nearest')
axs[i, j].axis('off')
fig.tight_layout(pad=0.1)
path = args.save_path + "/" + args.dataset + "/" + args.task
if not os.path.exists(path):
os.makedirs(path)
path += "/" + args.model_name
plt.savefig(path)
import chainer
import h5py
import numpy as np
import model
# Create a model object first
model = model.MLP()
def save_parameters_as_npz(model, filename='model.npz'):
# Save the model parameters into a NPZ file
chainer.serializers.save_npz(filename, model)
print('{} saved!\n'.format(filename))
# Load the saved npz from NumPy and show the parameter shapes
print('--- The list of saved params in model.npz ---')
saved_params = np.load('model.npz')
for param_key, param in saved_params.items():
print(param_key, '\t:', param.shape)
print('---------------------------------------------\n')
def save_parameters_as_hdf5(model, filename='model.h5'):
# Save the model parameters into a HDF5 archive
chainer.serializers.save_hdf5(filename, model)
print('model.h5 saved!\n')
# Load the saved HDF5 using h5py
print('--- The list of saved params in model.h5 ---')
f = h5py.File('model.h5', 'r')
dataset = RegressionDataset(X, Y)
# Reproducibility
if args.seed is not None:
torch.manual_seed(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
net = MLP()
criterion = nn.MSELoss()
optimizer = optim.Adam(net.parameters(), lr=args.lr, weight_decay=args.wd)
# Load reference net if defined
if args.repulsive is not None:
reference_net = model.MLP(dropout_rate=args.dropout_rate)
reference_net.load_state_dict(torch.load(Path(args.repulsive)))
# Update of the network parameters
train_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False)
# Sampling a repulsive bandwidth parameter
alpha = -3
beta = -0.5
bandwidth_repulsive = float(10**(alpha + (beta - alpha) * np.random.rand()))
# Preparation of the optimization
if args.repulsive is not None:
_optimize = partial(optimize,
bandwidth_repulsive=bandwidth_repulsive,
lambda_repulsive=args.lambda_repulsive)
if os.path.isfile(args.out_path):
os.remove(args.out_path)
print(args.out_path + ' Removed')
print('Cuda Mode is: {}'.format(args.cuda))
if args.cuda:
device = get_freer_gpu()
else:
device = torch.device('cpu')
print('Loading model')
ckpt = torch.load(args.cp_path, map_location=lambda storage, loc: storage)
model = model_.MLP(n_in=ckpt['input_size'],
nh=ckpt['n_hidden'],
n_h=ckpt['hidden_size'],
dropout_prob=ckpt['dropout_prob'])
model.load_state_dict(ckpt['model_state'], strict=True)
model.eval()
print('Model loaded')
print('Loading data')
data = {k.split('-')[0]: m for k, m in read_vec_flt_scp(args.path_to_data)}
if args.eval:
test_utts = read_trials(args.trials_path, eval_=args.eval)
else:
test_utts, attack_type_list, label_list = read_trials(args.trials_path,
eval_=args.eval)
def MLPClassifier(unsmodel, graphs, indexes, rep_dim, batchsize):
print('start classification')
split = int(len(indexes) * 0.9)
graph_train = []
graph_test = []
for i in indexes[0:split]:
graph_train.append(graphs[i])
for i in indexes[split:len(indexes)]:
graph_test.append(graphs[i])
serializers.load_npz(str(rep_dim) + "_model_ptc.npz", unsmodel)
hid_dim = 150
out_dim = 2
mlp = model.MLP(rep_dim, hid_dim, out_dim)
classifier = model.SoftmaxClassifier(mlp)
optimizer = chainer.optimizers.Adam()
optimizer.setup(classifier)
n_epochs = 30
# training phase
best = 0.00
for epoch in range(n_epochs):
print("epoch:", epoch)
perm = np.random.permutation(len(graph_train))
N_train = len(graph_train)
sum_loss = 0
sum_accuracy = 0
for i in range(0, N_train, batchsize):
maxid = min(i + batchsize, N_train)
graphids = []
adjs = []
atom_arrays = []
labels = []
for id in perm[i:maxid]:
graphids.append(graph_train[id][0])
adjs.append(graph_train[id][2])
atom_arrays.append(graph_train[id][1])
labels.append(graph_train[id][3])
graphids = np.asarray(graphids)
adjs = np.asarray(adjs, dtype=np.float32)
atom_arrays = np.asarray(atom_arrays, dtype=np.int32)
labels = np.asarray(labels, dtype=np.int32)
rep_list, counts = unsmodel.extract_fp(graphids, adjs, atom_arrays)
y = chainer.Variable(labels)
x = rep_list
optimizer.update(classifier, x, counts, y)
sum_loss += float(classifier.loss.data) * len(y.data)
sum_accuracy += float(classifier.accuracy.data) * len(y.data)
print("train acc:", sum_accuracy / N_train, "train loss:",
sum_loss / N_train)
if best < sum_accuracy:
serializers.save_npz(str(rep_dim) + "_nn_ptc.npz", classifier)
best = sum_accuracy
# test
graphids = []
adjs = []
atom_arrays = []
labels = []
serializers.load_npz(str(rep_dim) + "_nn_ptc.npz", classifier)
for id in range(len(graph_test)):
graphids.append(graph_test[id][0])
adjs.append(graph_test[id][2])
atom_arrays.append(graph_test[id][1])
labels.append(graph_test[id][3])
graphids = np.asarray(graphids)
adjs = np.asarray(adjs, dtype=np.float32)
atom_arrays = np.asarray(atom_arrays, dtype=np.int32)
labels = np.asarray(labels, dtype=np.int32)
rep_list, counts = unsmodel.extract_fp(graphids, adjs, atom_arrays)
x = rep_list
y = chainer.Variable(labels)
print("test acc:", classifier.accuracy.data)
#
# Processing input
#
print('Normalizing...')
normalization = norm.MinMax()
train_x = normalization.fit_and_normalize(train_x)
test_x = normalization.normalize(test_x)
x_test = normalization.normalize(x_test)
#
# Building the model
#
print("Training...")
mlp = model.MLP(len(columns) - 1, [30], 1, tf.nn.relu)
mlp.optimize(train_x, train_y, steps=10000, x_test=x_test, y_test=y_test)
#
# Testing model
#
print('Predicting...')
test_y_hat = mlp.predict(test_x)
if not is_local_train:
print("Exporting...")
result = test_y_hat
pd.DataFrame({
'id': test_id,
'target': result
}).to_csv('output/prediction/' + strftime("%Y%m%d%H%M%S", gmtime()) +
def main(args):
# use gpu ##########################################
device = torch.device("cuda" if args.gpu else "cpu")
torch.manual_seed(0)
# dataset ##########################################
if args.dataset == "mnist":
args.data_path = args.data_path + "mnist/"
if not os.path.exists(args.data_path):
os.makedirs(args.data_path)
train_set = datasets.MNIST(args.data_path,
train=True,
download=True,
transform=transforms.Compose([
transforms.Resize([32, 32]),
transforms.ToTensor()
]))
valid_set = datasets.MNIST(args.data_path,
train=False,
download=True,
transform=transforms.Compose([
transforms.Resize([32, 32]),
transforms.ToTensor()
]))
elif args.dataset == "shape":
train_set = utils.ShapeDataset(data_size=args.train_size)
valid_set = utils.ShapeDataset(data_size=args.valid_size)
elif args.dataset == "celeba":
train_set = utils.ImageFolder(args.data_path + '/train/',
transform=transforms.Compose([
transforms.CenterCrop(148),
transforms.Resize([64, 64]),
transforms.ToTensor()
]))
valid_set = utils.ImageFolder(args.data_path + '/val/',
transform=transforms.Compose([
transforms.CenterCrop(148),
transforms.Resize([64, 64]),
transforms.ToTensor()
]))
train_loader = torch.utils.data.DataLoader(train_set,
num_workers=32,
batch_size=args.batch_size)
valid_loader = torch.utils.data.DataLoader(valid_set,
num_workers=32,
batch_size=args.batch_size)
# init networks ##########################################
if args.dataset == "mnist":
if args.vae:
enc = model.MNIST_Encoder(args.n * 2)
dec = model.MNIST_Decoder(args.n, vae=True)
else:
enc = model.MNIST_Encoder(args.n)
dec = model.MNIST_Decoder(args.n)
elif args.dataset == "celeba":
if args.vae:
enc = model.CelebA_Encoder(args.n * 2)
dec = model.CelebA_Decoder(args.n, vae=True)
else:
enc = model.CelebA_Encoder(args.n)
dec = model.CelebA_Decoder(args.n)
elif args.dataset == "shape":
if args.vae:
enc = model.Shape_Encoder(args.n * 2)
dec = model.Shape_Decoder(args.n, vae=True)
else:
enc = model.Shape_Encoder(args.n)
dec = model.Shape_Decoder(args.n)
dec.to(device)
enc.to(device)
if not args.vae and args.l > 0:
mlp = model.MLP(args.n, args.l)
mlp.to(device)
# optimizer ##########################################
if args.l > 0:
optimizer = optim.Adam([
{
'params': dec.parameters(),
'lr': args.lr
},
{
'params': enc.parameters(),
'lr': args.lr
},
{
'params': mlp.parameters(),
'lr': args.lr
},
])
else:
optimizer = optim.Adam([
{
'params': dec.parameters(),
'lr': args.lr
},
{
'params': enc.parameters(),
'lr': args.lr
},
])
# train ################################################
save_path = args.checkpoint + "/" + args.dataset
if not os.path.exists(save_path):
os.makedirs(save_path)
for e in range(args.epochs):
recon_loss = 0
for yi, _, in tqdm(train_loader):
enc.train()
dec.train()
if args.l > 0:
mlp.train()
optimizer.zero_grad()
yi = yi.to(device)
z_hat = enc(yi)
if args.vae:
mu = z_hat[:, :args.n]
logvar = z_hat[:, args.n:]
z_bar = model.reparametrization(mu, logvar)
else:
if args.l > 0:
z_bar = mlp(z_hat)
else:
z_bar = z_hat
y_hat = dec(z_bar)
if args.vae:
loss = F.binary_cross_entropy(y_hat, yi)
else:
loss = F.mse_loss(y_hat, yi)
recon_loss += loss.item()
if args.vae:
loss -= args.beta * torch.mean(1 + logvar - mu.pow(2) -
logvar.exp())
loss.backward()
optimizer.step()
recon_loss /= len(train_loader)
z_norm = np.average(
np.sqrt(np.sum(z_hat.detach().cpu().numpy()**2, axis=1)))
print("epoch " + str(e) + '\ttraining loss = ' + str(recon_loss) +
'\tz norm = ' + str(z_norm))
# save model ##########################################
torch.save(enc.state_dict(), save_path + "/enc_" + args.model_name)
torch.save(dec.state_dict(), save_path + "/dec_" + args.model_name)
if args.l > 0:
torch.save(mlp.state_dict(), save_path + "/mlp_" + args.model_name)
valid_loss = 0
for yi, _ in tqdm(valid_loader):
enc.eval()
dec.eval()
if args.l > 0:
mlp.eval()
yi = yi.to(device)
z_eval = enc(yi)
if args.vae:
mu = z_eval[:, :args.n]
logvar = z_eval[:, args.n:]
z_bar_eval = model.reparametrization(mu, logvar)
else:
if args.l > 0:
z_bar_eval = mlp(z_eval)
else:
z_bar_eval = z_eval
y_eval = dec(z_bar_eval)
eval_loss = F.mse_loss(y_eval, yi)
valid_loss += eval_loss.item()
valid_loss /= len(valid_loader)
print("epoch " + str(e) + '\tvalid loss = ' + str(valid_loss))
