def train_model(gpu_count, image_shape, batch_gen, batch_gen_val, len_train_set, len_dev_set, len_class_size):
checkpoint = ModelCheckpoint(
filepath=args.model_save_path + args.model_name + '-sh='
+ str(args.sh) + '-ep={epoch:02d},bz=' + str(args.batch_size) + ',loss={loss:.4f}.h5',
monitor='loss',
verbose=1)
if gpu_count > 1:
with tf.device('/cpu:0'):
base_model = autoencoder(image_shape, len_class_size)
model = base_model.model()
print_summary(model, print_fn=lambda x: print(x, file=sys.stderr))
model.compile(loss='binary_crossentropy', optimizer='sgd')
checkpoint = DelegatingCallbackWithFixedModel(checkpoint, model)
model = multi_gpu_model(model, gpus=gpu_count)
else:
# base_model = autoencoder(image_shape, len_class_size)
base_model = ResNet50(include_top=True, weights=None, input_tensor=None,
input_shape=image_shape, pooling=None, classes=len_class_size)
model = base_model
print_summary(model, print_fn=lambda x: print(x, file=sys.stderr))
model.compile(loss='binary_crossentropy', optimizer='sgd')
model.fit_generator(
batch_gen,
steps_per_epoch=len_train_set // args.batch_size,
epochs=args.number_of_epochs,
verbose=1,
shuffle=True,
callbacks=[checkpoint],
validation_data=batch_gen_val,
validation_steps=len_dev_set // args.batch_size)
def cae_encode():
# Load the autoencoder graph
ae = model.autoencoder(input_shape=[None, 64, 64, 6])
# Load the data
data, names = datasets.load_6f_images(args.data_dir)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
with tf.Session() as sess:
# Restore weights/tensors from disk
saver.restore(sess, args.model_ckpt)
print("Model restored.")
# Evaluate the encoded tensor z
encoded = sess.run(ae['z'], feed_dict={ae['x']: data})
print('Encoded data shape:', encoded.shape)
# Save the encoded data
mkdir(args.results_path)
for i in range(data.shape[0]):
# Save the encoded map as an RGB image
cv2.imwrite(os.path.join(args.results_path, '%s.jpg' % names[i]),
encoded[i])
# Save the encoded map as a numpy file
np.save(os.path.join(args.results_path, '%s.npy' % names[i]),
encoded[i])
def pretrain(self):
""" Pretraining the weights for the deep SVDD network using autoencoder"""
ae = autoencoder(self.args.latent_dim).to(self.device)
ae.apply(weights_init_normal)
optimizer = optim.Adam(ae.parameters(),
lr=self.args.lr_ae,
weight_decay=self.args.weight_decay_ae)
scheduler = optim.lr_scheduler.MultiStepLR(
optimizer, milestones=self.args.lr_milestones, gamma=0.1)
ae.train()
for epoch in range(self.args.num_epochs_ae):
total_loss = 0
for x, _ in Bar(self.train_loader):
x = x.float().to(self.device)
optimizer.zero_grad()
x_hat = ae(x)
reconst_loss = torch.mean(
torch.sum((x_hat - x)**2, dim=tuple(range(1,
x_hat.dim()))))
reconst_loss.backward()
optimizer.step()
total_loss += reconst_loss.item()
scheduler.step()
print('Pretraining Autoencoder... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss / len(self.train_loader)))
self.save_weights_for_DeepSVDD(ae, self.train_loader)
def create_model(print_data=False):
bioma_shape = data_microbioma_train.shape[1]
if data_domain_train is not None:
domain_shape = data_domain_train.shape[1]
else:
domain_shape = None
models = autoencoder(
bioma_shape=bioma_shape,
#bioma_shape=717,
domain_shape=domain_shape,
output_shape=bioma_shape,
#output_shape=717,
latent_space=latent_space,
bioma_layers=layers,
domain_layers=domain_layers,
input_transform=input_transform,
output_transform=output_transform,
activation_function_encoder=activation,
activation_function_decoder=activation,
activation_function_latent=activation_latent)
model, encoder_bioma, encoder_domain, decoder_bioma = models
if print_data:
plot_models(model, encoder_bioma, encoder_domain, decoder_bioma)
compile_train(model,
encoder_bioma=encoder_bioma,
encoder_domain=encoder_domain,
reconstruction_error=reconstruction_loss,
encoded_comparison_error=losses.MeanAbsoluteError(),
metrics=get_experiment_metrics(input_transform,
output_transform),
optimizer=optimizer)
return model, encoder_bioma, encoder_domain, decoder_bioma
def test():
# Load the autoencoder graph
ae = model.autoencoder(input_shape=[None, 64, 64, 6])
# Load the data
data, names = datasets.load_6f_images(args.data_dir,
shuffle=True,
sample=False)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
with tf.Session() as sess:
# Restore weights/tensors from disk
saver.restore(sess, args.model_ckpt)
print("Model restored.")
# Evaluate test data in batches
batch_size = data.shape[0] // NUM_BATCHES
recon = np.ndarray(data.shape)
encoded = np.ndarray([data.shape[0], 16, 16, 3])
for i in range(NUM_BATCHES):
if i == NUM_BATCHES - 1:
batch_x = data[i * batch_size:]
recon[i * batch_size:] = sess.run(ae['y'],
feed_dict={ae['x']: batch_x})
encoded[i * batch_size:] = sess.run(
ae['z'], feed_dict={ae['x']: batch_x})
else:
batch_x = data[i * batch_size:i * batch_size + batch_size]
recon[i * batch_size:i * batch_size + batch_size] = sess.run(
ae['y'], feed_dict={ae['x']: batch_x})
encoded[i * batch_size:i * batch_size + batch_size] = sess.run(
ae['z'], feed_dict={ae['x']: batch_x})
# Save the various stages through the network
mkdir(args.results_path)
mkdir(os.path.join(args.results_path, 'reconstructions'))
mkdir(os.path.join(args.results_path, 'error_maps'))
mkdir(os.path.join(args.results_path, 'inputs'))
mkdir(os.path.join(args.results_path, 'encodings'))
for i in range(data.shape[0]):
# Save the reconstructed images
np.save(
os.path.join(args.results_path, 'reconstructions',
'%s.npy' % names[i]), recon[i])
# Save the encoded maps
np.save(
os.path.join(args.results_path, 'encodings', '%s.npy' % names[i]),
encoded[i])
# Save the input images
np.save(os.path.join(args.results_path, 'inputs', '%s.npy' % names[i]),
data[i])
# Save the error maps between input and reconstructed images
np.save(
os.path.join(args.results_path, 'error_maps', '%s.npy' % names[i]),
get_error_map(data[i], recon[i]))
def main(**kwargs):
opt.parse(kwargs)
opt.show()
model = autoencoder().cuda()
criterion = nn.MSELoss()
optimizer = t.optim.Adam(model.parameters(),
lr=opt.learning_rate,
weight_decay=1e-5)
dataloader = get_loader(opt)
if opt.load_from is not None:
state = t.load(opt.load_from)
model.load_state_dict(state['state_dict'])
optimizer.load_state_dict(state['optimizer'])
for epoch in range(opt.num_epochs):
for ii, data in enumerate(dataloader):
img, _ = data
img = Variable(img).cuda()
output = model(img)
loss = criterion(output, img)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if ii % 100 == 0:
print("step [{}:{}], loss {:.4f}".format(
epoch + 1, ii, loss.data[0]))
print("epoch [{}/{}], loss{:.4f}".format(epoch + 1, opt.num_epochs,
loss.data[0]))
if epoch % 5 == 0:
pic = to_img(output.cpu().data)
save_image(
pic,
os.path.join(opt.save_dir, 'dc_img',
'img_{}.png'.format(epoch)))
state = {
'epoch': epoch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}
t.save(
state,
os.path.join(opt.save_dir, 'model',
'ckpt_{}.pt'.format(epoch)))
def train():
# load mastcam data
train_data, train_names = datasets.load_6f_images(path=args.train_dir)
val_data, val_names = datasets.load_6f_images(path=args.val_dir)
ae = model.autoencoder(input_shape=[None, 64, 64, 6], loss=args.loss_fn, hybrid_lambda=args.hybrid_lambda)
learning_rate = 0.001
optimizer = tf.train.AdamOptimizer(learning_rate, epsilon=1.0).minimize(ae['cost'])
# We create a session to use the graph
sess = tf.Session()
train_writer = tf.summary.FileWriter(os.path.join(args.summaries_dir, 'train'),
sess.graph)
val_writer = tf.summary.FileWriter(os.path.join(args.summaries_dir, 'validation'))
sess.run(tf.global_variables_initializer())
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
# Fit all training data
num_batches = train_data.shape[0] / args.batch_size
print("num batches = %d" % num_batches)
step = 1
epochs = 1
prev_loss = 10000000
while True:
for batch_i in range(num_batches):
idx = batch_i*args.batch_size
batch_xs = train_data[idx:idx+args.batch_size]
sess.run(optimizer, feed_dict={ae['x']: batch_xs, ae['keep_prob']: 0.6})
train_loss = sess.run(ae['merged'], feed_dict={ae['x']: batch_xs, ae['keep_prob']: 0.6})
train_writer.add_summary(train_loss, step)
step += 1
val_loss = sess.run(ae['merged'], feed_dict={ae['x']: val_data, ae['keep_prob']: 1.0})
val_writer.add_summary(val_loss, step)
loss = sess.run(ae['cost'], feed_dict={ae['x']: val_data, ae['keep_prob']: 1.0})
print('Validation loss at Epoch %d (delta=%f)' % (epochs, prev_loss - loss), loss)
if prev_loss - loss < args.convergence_delta:
break
prev_loss = loss
epochs += 1
# Save the model for future training or testing
name = 'udr_12-8-3_3-3-3_nodrop_loss=%s_lambda=%f_epochs=%d_data=%s' % (args.loss_fn, args.hybrid_lambda, epochs, args.train_dir.split('/')[-2])
save_path = saver.save(sess, "/scratch/hkerner/saved_sessions/%s.ckpt" % name)
print("Model saved in path: %s" % save_path)
val_writer.close()
train_writer.close()
def main(args):
basedir = args.basedir
savedir = args.savedir
filelist = args.filelist
weights = args.weight_path
if filelist is not None:
with open(filelist) as f:
filenames = f.read().splitlines()
if not os.path.exists(savedir):
os.makedirs(savedir)
model = autoencoder()
model.load_weights(weights)
for filename in filenames:
filepath = os.path.join(basedir, 'images/%s.jpg' % (filename))
print(filepath)
img = cv2.imread(filepath)
img = cv2.resize(img, (256, 256))
img = img[:, :, [2, 1, 0]] # to RGB
x = np.array(img)
X = np.expand_dims(x, 0)
X = X / 127.5
X = X - 1.
y_pred = model.predict(X)
y_pred = np.argmax(y_pred, axis=-1)
pred_mask = y_pred.reshape((256, 256))
pred_mask = pred_mask.astype('int')
h, w = pred_mask.shape
ori = cv2.resize(img, (w, h))
for i in range(class_num + 1):
mask = (pred_mask == i).astype(np.bool)
color_mask = np.array(color_list[i], dtype=np.uint8)
alpha = 0.55
ori[mask] = ori[mask] * (1 - alpha) + color_mask * (alpha)
filesave = os.path.join(savedir, '%s.jpg' % (filename))
cv2.imwrite(filesave, ori)
def main(unused_argv):
if len(unused_argv
) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
if (FLAGS.mode != 'train'):
FLAGS.batch_size = 1
batcher = Batcher(FLAGS.dataset, "MNIST_data/", FLAGS.mode,
FLAGS.batch_size, FLAGS.err_type, FLAGS.err_frac,
FLAGS.antimode)
nfeatures = batcher.nfeatures
if (FLAGS.dataset == 'timeseries'):
model = rnnautoencoder(FLAGS.mode, FLAGS.batch_size, nfeatures)
else:
model = autoencoder(FLAGS.mode, FLAGS.batch_size, nfeatures)
if (FLAGS.mode == 'train'):
setup_training(model, batcher)
elif (FLAGS.mode == 'val'):
run_eval(model, batcher)
elif (FLAGS.mode == 'decode'):
run_decoding(model, batcher)
def run_inference(model_file, input, n_hidden, dim_z):
tf.reset_default_graph()
# network architecture
n_hidden = n_hidden
dim_input = input.shape[1] # number of samples per segment
dim_z = dim_z
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
x_hat = tf.placeholder(tf.float32,
shape=[None, dim_input],
name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_input], name='target_img')
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# input for PMLR
#z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable')
y, z, loss, neg_marginal_likelihood, KL_divergence = model.autoencoder(
x_hat, x, dim_input, dim_z, n_hidden, keep_prob)
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, model_file)
return sess.run((z, y, loss),
feed_dict={
x_hat: input,
x: input,
keep_prob: 1.0
})
def make_model(
data_dim,
latent_dim,
num_epochs,
):
# Layer graph
data = lbann.Input(data_field='samples')
autoencoder = model.autoencoder.FullyConnectedAutoencoder(
data_dim,
latent_dim,
)
reconstructed = autoencoder(data)
loss = lbann.MeanSquaredError(data, reconstructed)
# Metrics
metrics = [
lbann.Metric(loss, name='loss'),
]
# Callbacks
callbacks = [
lbann.CallbackPrint(),
lbann.CallbackTimer(),
lbann.CallbackDumpWeights(directory='weights',
epoch_interval=num_epochs),
]
# Contruct model
return lbann.Model(
num_epochs,
layers=lbann.traverse_layer_graph(loss),
objective_function=loss,
metrics=metrics,
callbacks=callbacks,
)
# Set TensorFlow to allow for growth. Helps compatibility.
import tensorflow as tf
from keras import backend as ktf
ktf.clear_session()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.Session(config=config)
ktf.set_session(session)
input_shape = (32, 32, 3)
target_size = input_shape[:2]
batch_size = 64
model = autoencoder()
# model = UNET()
model.compile(loss="mean_squared_error", optimizer=Adam(lr=0.001))
model.summary()
image_generator = ImageDataGenerator(
# rotation_range=15,
# width_shift_range=0.1,
# height_shift_range=0.1,
# shear_range=0.01,
# zoom_range=[0.9, 1.25],
horizontal_flip=False,
vertical_flip=False,
# fill_mode='reflect',
def test(model, args):
data_path = args.data_path
n_channels = args.channels
n_classes = args.classes
data_width = args.width
data_height = args.height
gpu = args.gpu
# Hyper paremter for MagNet
thresholds = [0.01, 0.05, 0.001, 0.005]
reformer_model = None
if args.reformer == 'autoencoder1':
reformer_model = autoencoder(n_channels)
elif args.reformer == 'autoencoder2':
reformer_model = autoencoder2(n_channels)
else:
print("wrong reformer model : must be autoencoder1 or autoencoder2")
raise SystemExit
print('reformer model')
summary(reformer_model,
input_size=(n_channels, data_height, data_width),
device='cpu')
detector_model = None
if args.detector == 'autoencoder1':
detector_model = autoencoder(n_channels)
elif args.detector == 'autoencoder2':
detector_model = autoencoder2(n_channels)
else:
print("wrong detector model : must be autoencoder1 or autoencoder2")
raise SystemExit
print('detector model')
summary(detector_model,
input_size=(n_channels, data_height, data_width),
device='cpu')
# set device configuration
device_ids = []
if gpu == 'gpu':
if not torch.cuda.is_available():
print("No cuda available")
raise SystemExit
device = torch.device(args.model_device1)
device_defense = torch.device(args.defense_model_device)
device_ids.append(args.model_device1)
if args.model_device2 != -1:
device_ids.append(args.model_device2)
if args.model_device3 != -1:
device_ids.append(args.model_device3)
if args.model_device4 != -1:
device_ids.append(args.model_device4)
else:
device = torch.device("cpu")
device_defense = torch.device("cpu")
detector = AEDetector(detector_model,
device_defense,
args.detector_path,
p=2)
reformer = SimpleReformer(reformer_model, device_defense,
args.reformer_path)
classifier = Classifier(model, device, args.model_path, device_ids)
# set testdataset
test_dataset = SampleDataset(data_path)
test_loader = DataLoader(
test_dataset,
batch_size=10,
num_workers=4,
)
print('test_dataset : {}, test_loader : {}'.format(len(test_dataset),
len(test_loader)))
# Defense with MagNet
print('test start')
for thrs in thresholds:
print('----------------------------------------')
counter = 0
avg_score = 0.0
thrs = torch.tensor(thrs)
with torch.no_grad():
for batch_idx, (inputs, labels) in enumerate(test_loader):
inputs = inputs.float()
labels = labels.to(device).long()
target = make_one_hot(labels[:, 0, :, :], n_classes, device)
operate_results = operate(reformer, classifier, inputs)
all_pass, _ = filters(detector, inputs, thrs)
if len(all_pass) == 0:
continue
filtered_results = operate_results[all_pass]
pred = filtered_results.to(device).float()
target = target[all_pass]
loss = dice_score(pred, target)
avg_score += loss.data.cpu().numpy()
# statistics
counter += 1
del inputs, labels, pred, target, loss
if counter:
avg_score = avg_score / counter
print('threshold : {:.4f}, avg_score : {:.4f}'.format(
thrs, avg_score))
else:
print(
'threshold : {:.4f} , no images pass from filter'.format(thrs))
label="Error" if name == 1 else "Normal")
ax.legend()
plt.title("Reconstruction error for different classes")
plt.ylabel("Reconstruction error")
plt.xlabel("Data point index")
plt.show()
if __name__ == '__main__':
#data import
filename = 'Book1.csv'
df = pd.read_csv(filename)
df_train, df_valid, df_test, df_test_y = preprocessing(df)
#create the model
model = autoencoder(df_train.shape[1])
model.summary()
#train the model
output = model.fit(df_train, df_valid)
train_plot(output)
#predict
model.load_model('autoencoder_v1.h5')
x_pred = model.predict(df_test)
#calculate and plot the reconstruction loss
error = reconstruction_loss(df_test, x_pred, df_test_y)
error_plot(error)
torch.save(model_state_dict, model_path)
return loss_history
if __name__ == "__main__":
args = get_args()
n_channels = args.channels
n_classes = args.classes
model = None
if args.model_number == 1:
model = autoencoder(n_channels)
elif args.model_number == 2:
model = autoencoder2(n_channels)
else:
print("wrong model number : must be 1 or 2")
raise SystemExit
print('Training Autoencoder {}'.format(str(args.model_number)))
summary(model,
input_size=(n_channels, args.height, args.width),
device='cpu')
loss_history = train_net(model, args)
def train(args):
##parameters
n_steps = args.n_steps
n_input = args.n_input
batch_size = args.batch_size
dropout_constant = args.dropout_constant
## Underlying graph
graph = tf.Graph()
with graph.as_default():
#data
with tf.name_scope('input'):
x = tf.placeholder(tf.float32, [None, n_input], name='x-input')
with tf.name_scope('dropout'):
keep_prob = tf.placeholder(tf.float32)
tf.summary.scalar('dropout_keep_probability', keep_prob)
with tf.name_scope('noise'):
noise_std = tf.placeholder(tf.float32)
tf.summary.scalar('dropout_keep_probability', noise_std)
#model
code, reconstruction = autoencoder(x,
dropout=keep_prob,
noise_std=noise_std)
#loss
with tf.name_scope('MSE_loss'):
loss = tf.reduce_sum(tf.square(x - reconstruction))
global_step = tf.Variable(0) # count the number of steps taken.
learning_rate = tf.train.exponential_decay(0.01, global_step, 100,
0.91)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(loss,
global_step=global_step)
tf.summary.scalar("loss", loss)
#logging
log_dir = args.log_dir
if tf.gfile.Exists(log_dir):
tf.gfile.DeleteRecursively(log_dir)
tf.gfile.MakeDirs(log_dir)
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(log_dir + '/train', graph=graph)
test_writer = tf.summary.FileWriter(log_dir + '/test')
#training
sess = tf.InteractiveSession(graph=graph)
tf.global_variables_initializer().run()
mean_img_train = np.mean(mnist.train.images[:50000], axis=0)
mean_img_validation = np.mean(mnist.train.images[50000:55000], axis=0)
x_valid = [img - mean_img_validation
for img in mnist.train.images][50000:55000]
for i in range(n_steps):
if i % 10 == 0:
#test error
cost, summary = sess.run([loss, merged],
feed_dict={
x: x_valid,
keep_prob: 1.0,
noise_std: 0
})
test_writer.add_summary(summary, i)
print "Loss at step %d: %.1f" % (i, cost)
else:
# Record train set summaries and train
offset = (i * batch_size) % (50000 - batch_size)
# Generate a minibatch.
batch_data = mnist.train.images[offset:(offset +
batch_size), :]
x_batch = np.array(
[img - mean_img_train for img in batch_data])
# Record execution stats (every 100th step)
if i % 100 == 99:
run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
_, summary = sess.run([optimizer, merged],
feed_dict={
x: x_batch,
keep_prob: dropout_constant,
noise_std: 0.05
},
options=run_options,
run_metadata=run_metadata)
train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
train_writer.add_summary(summary, i)
print('Adding run metadata for', i)
else:
_, cost, summary = sess.run([optimizer, loss, merged],
feed_dict={
x: x_batch,
keep_prob:
dropout_constant,
noise_std: 0.05
})
train_writer.add_summary(summary, i)
train_writer.close()
test_writer.close()
print(
"For Autoencoder tensorboard logs run 'tensorboard --logdir=%s'" %
log_dir)
#Autoencoder Benchmarking
#Embeddings from encoded train set
train_size = 55000
mean_img_train = np.mean(mnist.train.images[:train_size], axis=0)
for i in range(train_size / 100):
step = i * 100
x_mnist_train, y_mnist_train = mnist.train.images[
step:step + 100], mnist.train.labels[step:step + 100]
x_mnist_train_norm = np.array(
[img - mean_img_train for img in x_mnist_train])
new_embedds = sess.run(code,
feed_dict={
x: x_mnist_train_norm,
keep_prob: 1,
noise_std: 0
})
if i == 0:
train_embedds = new_embedds
else:
train_embedds = np.concatenate((train_embedds, new_embedds),
axis=0)
#Multiclass LogRegression
clf = LogisticRegression(multi_class='multinomial', solver='lbfgs')
clf.fit(train_embedds,
np.argmax(mnist.train.labels[:train_size], axis=1))
#Embeddings from encoded train set
test_size = 10000
mean_img_test = np.mean(mnist.test.images, axis=0)
for i in range(test_size / 100):
step = i * 100
x_mnist_test, y_test = mnist.test.images[
step:step + 100], mnist.test.labels[step:step + 100]
x_mnist_test_norm = np.array(
[img - mean_img_train for img in x_mnist_test])
new_embedds = sess.run(code,
feed_dict={
x: x_mnist_test_norm,
keep_prob: 1,
noise_std: 0
})
if i == 0:
test_embedds = new_embedds
else:
test_embedds = np.concatenate((test_embedds, new_embedds),
axis=0)
#LogRegression Accuracy
accuracy = np.mean(
clf.predict(test_embedds) == np.argmax(
mnist.test.labels[:test_size], axis=1))
print('Accuracy: %.2f%%' % (accuracy * 100))
confusion_matrix_op_1, cross_entropy_1, train_op_1, global_step_tensor_1, saver_1, accuracy_1, lhs_1, rhs_1 = FourLayerConvNet(
input, output, args.learning_rate, args.momentum_1, args.momentum_2)
print("LABELS")
print(labels.shape)
print("=======================================")
print("DATA SHAPE")
print(data.shape)
else:
# get ImageNet data and process its
data = np.load('/work/cse496dl/shared/homework/02/imagenet_images.npy')
train_data = np.reshape(data, [-1, 32, 32, 3])
train_num_examples = train_data.shape[0]
# image net
total_loss_1, train_op_1, global_step_tensor_1, saver_1 = autoencoder(
input, args.learning_rate, args.momentum_1, args.momentum_2)
print("=======================================")
print("DATA SHAPE")
print(data.shape)
# Training
with tf.Session() as session:
# initialize variables
session.run(tf.global_variables_initializer())
# batch size
batch_size = args.batch_size
# Hypterparameter information
print('Model: {}'.format(args.load_data))
def run_single_model(val, loss="mean_squared_error"):
ae, encoder = autoencoder(val.shape[1], loss=loss)
ae.fit(val, val, batch_size=32, epochs=EPOCHS)
bottleneck_representation = encoder.predict(val)
cluster = k_means(bottleneck_representation, CLUSTER)
return cluster, bottleneck_representation
dataset = []
for i in range(2):
dataset.append(CustomDataset(data_dir, i))
dataloaders = {
x: torch.utils.data.DataLoader(dataset[x],
batch_size=batch_size,
shuffle=True,
num_workers=12)
for x in range(2)
}
dataset_sizes = {x: len(dataloaders[x]) for x in range(2)}
model = autoencoder(learning_rate).cuda()
criterion = nn.MSELoss()
for epoch in range(num_epochs):
for actor in range(2):
cum_loss = []
tot = 0
model.setMode(actor)
for warped, original in dataloaders[actor]:
img = warped.float()
img = Variable(img).cuda()
original = original.float()
original = Variable(original).cuda()
num_epochs = 10
batch_size = 4
learning_rate = 1e-3
img_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((image_size,image_size)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
dataset_training = RainyDataset('rainy-image-dataset/training', transform=img_transform)
total_train = len(dataset_training)
dataloader_training = DataLoader(dataset_training, batch_size=batch_size, shuffle=True,num_workers=4)
model = autoencoder().cuda()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,
weight_decay=1e-5)
model.train()
print("Training model, total samples %d"%total_train)
for epoch in range(num_epochs):
epoch_loss = 0
os.makedirs('%s/epoch_%d'%(img_dirs,epoch),exist_ok=True)
ssim = 0
for index,data in enumerate(dataloader_training):
clean_img = data["clean"]
rainy_img = data["rain"]
f_rain = data["fourier_rain"]
def main(args):
path_dataset = args.dataset # '/home/philyang/drone/data/data512'
traintxt = args.traintxt # '/home/philyang/drone/data/data512/train.txt'
trainGen = DataGen(filepath=traintxt, path_dataset=path_dataset)
# trainGen = DataGenCifar10(batch_size=4, class_num=10, dim=(256,256), n_channels=3)
valtxt = args.valtxt
valGen = DataGen(filepath=valtxt, path_dataset=path_dataset)
# valGen = DataGenCifar10(batch_size=4, class_num=10, dim=(256,256), n_channels=3)
# define checkpoint
dataset_name = trainGen.name()
dirname = 'ckpt-' + dataset_name
if not os.path.exists(dirname):
os.makedirs(dirname)
timestr = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
filepath = os.path.join(dirname, 'weights-%s-{epoch:02d}-{loss:.2f}.hdf5' %(timestr))
checkpoint = ModelCheckpoint(filepath=filepath,
monitor='val_loss', # acc outperforms loss
verbose=1,
save_best_only=False,
save_weights_only=True,
period=5)
# define logs for tensorboard
tensorboard = TensorBoard(log_dir='logs', histogram_freq=0)
wgtdir = 'weights'
if not os.path.exists(wgtdir):
os.makedirs(wgtdir)
strategy = tf.distribute.MirroredStrategy()
print("Number of devices: {}".format(strategy.num_replicas_in_sync))
# Open a strategy scope.
# with strategy.scope():
model = autoencoder()
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.001), loss=sparse_crossentropy)
model.summary()
start_epoch = 0
# Load weight of unfinish training model(optional)
if args.weights is not None and args.start_epoch is not None:
weights_path = args.weights
start_epoch = int(args.start_epoch)
model.load_weights(weights_path)
model.fit_generator(
generator=trainGen,
steps_per_epoch=len(trainGen),
validation_data=valGen,
validation_steps=len(valGen),
initial_epoch=start_epoch,
epochs=1000,
callbacks=[checkpoint,tensorboard],
use_multiprocessing=False,
verbose=1,
workers=1,
max_queue_size=10)
model.save('./model.h5')
savedir = './results/run' \
if args.savedir is None else args.savedir
if not os.path.isdir(savedir):
os.makedirs(savedir)
# get data
xtr, ytr, xte, yte = mnist_1000(args.mnist_path)
# placeholders
x = tf.placeholder(tf.float32, [None, 784])
n_train_batches = int(1000/args.batch_size)
n_test_batches = int(1000/args.batch_size)
# models
net = autoencoder(x, args.zdim, True) # train
tnet = autoencoder(x, args.zdim, False, reuse=True) # test
# for visualization
z = tf.placeholder(tf.float32, [None, args.zdim])
tennet = encoder(x, args.zdim, reuse=True) # test encoder
tdenet = decoder(z, reuse=True) # test decoder
def train():
loss = -net['elbo'] # negative ELBO
global_step = tf.train.get_or_create_global_step()
lr = tf.train.piecewise_constant(tf.cast(global_step, tf.int32),
[int(n_train_batches*args.n_epochs/2)], [1e-3, 1e-4])
train_op = tf.train.AdamOptimizer(lr).minimize(loss,
global_step=global_step)
def main(args, train_data, test_data):
tf.reset_default_graph()
""" parameters """
# network architecture
n_hidden = args.n_hidden
dim_input = train_data.shape[1] # number of samples per segment
dim_z = args.dim_z
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
run_name = "{}_{}_{}_{}".format(
args.encoder, ('iaf' if args.iaf else ('mmd' if args.mmd else 'kl')),
str(args.dim_z), args.run_name) + ('_mse' if args.mse else '')
print(run_name)
""" prepare data """
n_train = train_data.shape[0]
n_test = test_data.shape[0]
""" build graph """
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
x_hat = tf.placeholder(tf.float32,
shape=[None, dim_input],
name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_input], name='target_img')
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# input for PMLR
#z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable')
# network architecture
y, z, loss, neg_marginal_likelihood, KL_divergence, norm =\
model.autoencoder(x, x, dim_input, dim_z, n_hidden, keep_prob,
encoder=args.encoder,
decoder=args.decoder,
use_iaf=args.iaf,
use_mmd=args.mmd,
mse=args.mse)
s1 = tf.summary.scalar('train/loss', loss)
s2 = tf.summary.scalar('train/neg_marginal_likelihood',
neg_marginal_likelihood)
s3 = tf.summary.scalar('train/KL_divergence', KL_divergence)
s4 = tf.summary.scalar('norm', norm)
training_summaries = tf.summary.merge([s1, s2, s3, s4])
# optimization
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
""" training """
# save
saver = tf.train.Saver()
# train
n_batches_train = np.ceil(n_train / batch_size).astype(int)
n_batches_test = np.ceil(n_test / batch_size).astype(int)
min_tot_loss = 1e99
all_losses = []
all_likelihoods = []
all_divergences = []
with tf.Session() as sess:
# train model
if args.visualize_sample == -1:
# Random shuffling -> disable for now
# np.random.shuffle(train_data)
writer = tf.summary.FileWriter(
'/cache/tensorboard-logdir/{}'.format(run_name),
graph=tf.get_default_graph())
with open('{}.log'.format(run_name), 'w') as logfile:
print('Training model {}'.format(run_name))
sess.run(tf.global_variables_initializer(),
feed_dict={keep_prob: 0.9})
for epoch in range(n_epochs):
# For collecting latent dim embeddings
z_out = np.zeros((0, dim_z))
test_losses = []
test_likelihoods = []
test_divergences = []
train_losses = []
train_likelihoods = []
train_divergences = []
# Loop over all batches
for i in range(n_batches_train):
# Compute the offset of the current minibatch in the data.
offset = i * batch_size
batch_train_input = train_data[offset:(offset +
batch_size)]
_, tot_loss, loss_likelihood, loss_divergence, train_summary, z_in = sess.run(
(train_op, loss, neg_marginal_likelihood,
KL_divergence, training_summaries, z),
feed_dict={
x_hat: batch_train_input,
x: batch_train_input,
keep_prob: 1.0
})
writer.add_summary(train_summary,
epoch * n_batches_train + i)
train_losses.append(tot_loss)
train_likelihoods.append(loss_likelihood)
train_divergences.append(loss_divergence)
# Add embeddings to list
z_out = np.concatenate((z_out, z_in), axis=0)
for i in range(n_batches_test):
offset = i * batch_size
batch_test_input = test_data[offset:(offset +
batch_size)]
test_loss, test_likelihood, test_divergence, reconstr, z_in = sess.run(
(loss, neg_marginal_likelihood, KL_divergence, y,
z),
feed_dict={
x_hat: batch_test_input,
x: batch_test_input,
keep_prob: 1.0
})
test_losses.append(test_loss)
test_likelihoods.append(test_likelihood)
test_divergences.append(test_divergence)
z_out = np.concatenate((z_out, z_in), axis=0)
all_losses += test_losses
all_likelihoods += test_likelihoods
all_divergences += test_divergences
test_summaries = tf.Summary()
test_summaries.value.add(tag="test/loss",
simple_value=np.mean(test_losses))
test_summaries.value.add(
tag="test/neg_marginal_likelihood",
simple_value=np.mean(test_likelihoods))
test_summaries.value.add(
tag="test/KL_divergence",
simple_value=np.mean(test_divergences))
writer.add_summary(test_summaries,
(epoch + 1) * n_batches_train - 1)
# print cost every epoch
train_line = "epoch %d: L_tot %.2E L_likelihood %.2E L_divergence %.2E" % (
epoch, tot_loss, loss_likelihood, loss_divergence)
test_line = " test: L_tot %.2E L_likelihood %.2E L_divergence %.2E" % (
test_loss, test_likelihood, test_divergence)
logfile.write(train_line + '\n')
logfile.write(test_line + '\n')
print(train_line)
print(test_line)
# if minimum loss is updated or final epoch, plot results
if test_loss < min_tot_loss:
min_tot_loss = test_loss
#with open('min_{}.txt'.format(run_name), 'w') as log:
# log.write('Minimum total loss: ' + str(test_loss) + '\n')
# log.write('Minimum likelihood: ' + str(test_likelihood) + '\n')
# log.write('Minimum divergence: ' + str(test_divergence) + '\n')
#batch_test_input = np.reshape(batch_train_input, (-1, nchannel, 128))
#reconstr = np.reshape(reconstr, (-1, nchannel, 128))
#for ch in range(nchannel):
# plot_to_file('./images/reconstruction_{}.png'.format(ch),
# batch_test_input[0][ch], reconstr[0][ch])
# fft = lambda x: np.abs(np.fft.fft(x - np.mean(x)))
# plot_to_file('./images/fft_{}.png'.format(ch),
# fft(batch_test_input[0][ch]), fft(reconstr[0][ch]))
# if training is finished
if epoch + 1 == n_epochs:
#save_embedding(np.concatenate((train_data, test_data)), z_out, sess, writer, channel_idx)
save_path = saver.save(
sess, '/cache/model-{}.ckpt'.format(run_name))
print('Model saved to {}'.format(save_path))
#np.save('losses_{}'.format(run_name), all_losses)
#np.save('likelihoods_{}'.format(run_name), all_likelihoods)
#np.save('divergences_{}'.format(run_name), all_divergences)
#moving_average_n = 10
#plot_training('{}.png'.format(run_name),
# [np.convolve(x, np.ones((moving_average_n,))/moving_average_n, mode='valid') for x in
# [all_losses, all_likelihoods, all_divergences]],
# ['Total loss', 'Loss likelihood', 'KL divergence'])
batch_test_input = np.reshape(batch_train_input,
(-1, nchannel, 128))
reconstr = np.reshape(reconstr, (-1, nchannel, 128))
for ch in range(nchannel):
plot_to_file(
'./images/reconstruction_{}.png'.format(ch),
batch_test_input[0][ch], reconstr[0][ch])
fft = lambda x: np.abs(np.fft.fft(x - np.mean(x)))
plot_to_file('./images/fft_{}.png'.format(ch),
fft(batch_test_input[0][ch]),
fft(reconstr[0][ch]))
# visualize model
else:
saver.restore(sess, './logs/model-{}.ckpt'.format(args.run_name))
with h5py.File('/data/eeg_channels.h5', 'r') as h5f:
input = [
(h5f['one_sec_norm'][args.channel,
args.visualize_sample, :] + 1.0) / 2.0
]
latent_space, reconstr, loss_sample = sess.run(
(z, y, loss),
feed_dict={
x_hat: input,
x: input,
keep_prob: 1.0
})
plot_to_file(
'./logs/{}/reconstruction_{}.png'.format(
args.channel, args.visualize_sample), input[0],
reconstr[0])
plot_to_file(
'./logs/{}/freq_{}.png'.format(args.channel,
args.visualize_sample),
scipy.signal.periodogram(input[0] * 256),
scipy.signal.periodogram(reconstr[0] * 256))
def main():
args = parse_args()
print("Params:")
print(args)
print()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
X = tf.placeholder(tf.float32, [17770, None], name='X')
Y = tf.placeholder(tf.float32, [17770, None], name='Y')
Yhat, weights = model.autoencoder(X,
args.layers,
keep_prob=(1.0 - args.dropout),
constrained=args.constrained)
YhatDev, weights = model.autoencoder(X,
args.layers,
constrained=args.constrained,
weights=weights)
loss = model.get_loss(Y, Yhat)
loss_sum, loss_examples = model.get_test_loss(Y, Yhat)
loss_sum_dev, loss_examples_dev = model.get_test_loss(Y, YhatDev)
losses = (loss, loss_sum, loss_examples, loss_sum_dev, loss_examples_dev)
optimizer = model.get_optimizer(args.optimizer_type, args.lr,
args.momentum)
if args.small_dataset:
train_path = "../data/netflix/output_small_train"
dev_path = "../data/netflix/output_small_dev"
test_path = "../data/netflix/output_small_test"
else:
train_path = "../data/netflix/output_train"
dev_path = "../data/netflix/output_dev"
test_path = "../data/netflix/output_test"
data_train = data_manager.Data(size=args.chunk_size,
batch=args.batch_size,
path=train_path)
data_dev = data_manager.Data(size=args.chunk_size,
batch=args.batch_size,
path=dev_path,
test=True)
data_test = data_manager.Data(size=args.chunk_size,
batch=args.batch_size,
path=test_path,
test=True)
train_losses, eval_losses = model.train(
data_train,
data_dev,
losses,
optimizer,
X,
Y,
Yhat,
epochs=args.epochs,
dense_refeeding=args.dense_refeeding)
model.test(data_test, X, Y, YhatDev)
t, = plt.plot([i + 1 for i in range(len(train_losses))],
train_losses,
label="Train")
e, = plt.plot([i + 1 for i in range(len(eval_losses))],
eval_losses,
label="Dev")
plt.legend(handles=[t, e])
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.show()
print([i + 1 for i in range(len(train_losses))])
print(train_losses)
print([i + 1 for i in range(len(eval_losses))])
print(eval_losses)
# learn (75%) test (25%)
trainX, testX = train_test_split(data, test_size=0.2)
trainX = np.asarray(trainX).astype("float32") / 255.0
testX = np.asarray(testX).astype("float32") / 255.0
# Noises
trainNoise = np.random.normal(loc=0.5, scale=0.5, size=trainX.shape)
testNoise = np.random.normal(loc=0.5, scale=0.5, size=testX.shape)
trainXNoisy = np.clip(trainX + trainNoise, 0, 1)
testXNoisy = np.clip(testX + testNoise, 0, 1)
print("[INFO] building autoencoder...")
input_img = Input(shape=(IMAGE_HEIGHT, IMAGE_WIDTH, 3))
autoencoder = Model(input_img, autoencoder(input_img))
autoencoder.compile(loss="mean_squared_error", optimizer=RMSprop())
H = autoencoder.fit(trainXNoisy,
trainX,
validation_data=(testXNoisy, testX),
epochs=EPOCHS,
batch_size=BS,
shuffle=True,
callbacks=[TensorBoard(log_dir='/tmp/autoencoder')])
N = np.arange(0, EPOCHS)
plt.style.use("ggplot")
plt.figure()
plt.plot(N, H.history["loss"], label="train_loss")
plt.plot(N, H.history["val_loss"], label="val_loss")
