def main():
args = args_parse()
enc_path = args.enc
dis_path = args.dis
device = torch.device('cuda')
# Init models
Encoder = encoder(1, 1, 16).to(device)
Encoder.load_state_dict(torch.load(enc_path, map_location=device))
Encoder.eval()
Discriminator = discriminator().to(device)
Discriminator.load_state_dict(torch.load(dis_path, map_location=device))
Discriminator.eval()
models = {'enc': Encoder, 'dis': Discriminator}
# Init data
val_set = ppmi()
# Extract features
ft_vectors, subject_list, im_list = extract_features(
models, val_set, device)
distance_matrix = get_dist(ft_vectors)
rel_matrix = get_rel(subject_list, im_list)
# Compute similarity and rank similarity
subject_dict = get_subject_dict(im_list)
# Compute sensitivity, precision and d-prime
MAP = compute_MAP(distance_matrix, im_list, subject_dict, rel_matrix, 5)
print('MAP:{}'.format(MAP))
def compute_ms_ssim(dataset, encryptor=None, device=None):
if encryptor != None:
Encryptor = encoder(1, 1, 16).to(device)
Encryptor.load_state_dict(torch.load(encryptor, map_location=device))
Encryptor.eval()
loader = data.DataLoader(dataset,
batch_size=1,
num_workers=16,
pin_memory=True,
shuffle=True)
pos_ms_ssim = []
neg_ms_ssim = []
start = time()
for step, (x, x_ref, y, y_ref, d, d_p, d_n, im,
im_ref) in enumerate(loader):
if encryptor != None:
with torch.no_grad():
x, x_ref = x.to(device), x_ref.to(device)
x = Encryptor(x).cpu()
x_ref = Encryptor(x_ref).cpu()
x = x[0, 0, :, :, :].numpy().astype(float)
x_ref = x_ref[0, 0, :, :, :].numpy().astype(float)
ms_ssim_score = ssim(x, x_ref)
if d.item() == 1:
pos_ms_ssim += [ms_ssim_score]
elif d.item() == 0:
neg_ms_ssim += [ms_ssim_score]
dur = time() - start
print('|- Compute ms-ssim scores, duration: {:.0f} sec'.format(dur))
return pos_ms_ssim, neg_ms_ssim
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--encoder', type=str)
parser.add_argument('--segmentation', type=str)
parser.add_argument('--discriminator', type=str)
parser.add_argument('--dataset', type=str, default='ppmi')
args = parser.parse_args()
encoder_path = args.encoder
discriminator_path = args.discriminator
segmentation_path = args.segmentation
batch_size = 16
device = torch.device('cuda')
if args.dataset == 'ppmi':
val_set = ppmi_pairs(mode = 'val')
#if args.dataset == 'iseg':
# val_set = iseg_pairs()
'''Initialize networks'''
# init model encrypter
Encrypter = encoder(1,1,16).to(device)
Encrypter.load_state_dict(torch.load(encoder_path, map_location=device))
print('Load:{}'.format(encoder_path))
# init discriminator
Discriminator = discriminator().to(device)
Discriminator.load_state_dict(torch.load(discriminator_path, map_location=device))
print('Load:{}'.format(discriminator_path))
# init segmentator
Segmentator = segnet(1,6,32).to(device)
Segmentator.load_state_dict(torch.load(segmentation_path, map_location=device))
print('Load:{}'.format(segmentation_path))
#
models = {'enc': Encrypter, 'seg': Segmentator, 'dis': Discriminator}
# declare loss function
Segment_criterion = Dice_Loss()
Discrimination_criterion = torch.nn.CrossEntropyLoss()
criterions = {'seg': Segment_criterion, 'dis': Discrimination_criterion}
seg_loss, adv_loss, dis_acc, dice_score = val_epoch(models, criterions, val_set, batch_size, device)
def main(args=None):
args = ku.parse_model_args(args)
N = args.N_train + args.N_test
train = np.arange(args.N_train)
test = np.arange(args.N_test) + args.N_train
X, Y, X_raw = sample_data.periodic(N,
args.n_min,
args.n_max,
even=args.even,
noise_sigma=args.sigma,
kind=args.data_type)
if args.even:
X = X[:, :, 1:2]
else:
X[:, :, 0] = ku.times_to_lags(X_raw[:, :, 0])
X[np.isnan(X)] = -1.
X_raw[np.isnan(X_raw)] = -1.
Y = sample_data.phase_to_sin_cos(Y)
scaler = StandardScaler(copy=False, with_mean=True, with_std=True)
scaler.fit_transform(Y)
if args.loss_weights: # so far, only used to zero out some columns
Y *= args.loss_weights
model_type_dict = {'gru': GRU, 'lstm': LSTM, 'vanilla': SimpleRNN}
model_input = Input(shape=(X.shape[1], X.shape[-1]), name='main_input')
encode = encoder(model_input,
layer=model_type_dict[args.model_type],
output_size=Y.shape[-1],
**vars(args))
model = Model(model_input, encode)
run = ku.get_run_id(**vars(args))
history = ku.train_and_log(X[train], Y[train], run, model, **vars(args))
return X, Y, X_raw, scaler, model, args
def get_model(sess, image_shape=(80, 160, 3), gf_dim=64, df_dim=64, batch_size=64,
name="transition", gpu=0):
K.set_session(sess)
checkpoint_dir = './results_' + name
with tf.variable_scope(name):
# sizes
ch = image_shape[2]
rows = [image_shape[0]/i for i in [16, 8, 4, 2, 1]]
cols = [image_shape[1]/i for i in [16, 8, 4, 2, 1]]
G = autoencoder.generator(batch_size*out_leng, gf_dim, ch, rows, cols)
G.compile("sgd", "mse")
E = autoencoder.encoder(batch_size*(time+out_leng), df_dim, ch, rows, cols)
E.compile("sgd", "mse")
G.trainable = False
E.trainable = False
# nets
T = transition(batch_size)
T.compile("sgd", "mse")
t_vars = T.trainable_weights
print "T.shape: ", T.output_shape
Img = Input(batch_shape=(batch_size, time+out_leng,) + image_shape)
Z = Input(batch_shape=(batch_size, time+out_leng, 2)) # controls signal
I = K.reshape(Img, (batch_size*(time+out_leng),)+image_shape)
code = E(I)[0]
code = K.reshape(code, (batch_size, time+out_leng, z_dim))
inp = K.concatenate([Z, code], axis=2)
target = code[:, time:, :]
out = T(inp)
G_dec = G(K.reshape(out, (batch_size*out_leng, z_dim)))
# costs
loss = tf.reduce_mean(tf.square(target - out))
print "Transition variables:"
for v in t_vars:
print v.name
t_optim = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(loss, var_list=t_vars)
tf.initialize_all_variables().run()
# summaries
sum_loss = tf.scalar_summary("loss", loss)
sum_e_mean = tf.histogram_summary("e_mean", code)
sum_out = tf.histogram_summary("out", out)
sum_dec = tf.image_summary("E", G_dec)
# saver
saver = tf.train.Saver()
t_sum = tf.merge_summary([sum_e_mean, sum_out, sum_dec, sum_loss])
writer = tf.train.SummaryWriter("/tmp/logs/"+name, sess.graph)
# functions
def train_d(images, z, counter, sess=sess):
return 0, 0, 0
def train_g(images, z, counter, sess=sess):
outputs = [loss, G_dec, t_sum, t_optim]
outs = sess.run(outputs, feed_dict={Img: images, Z: z, K.learning_phase(): 1})
gl, samples, sums = outs[:3]
writer.add_summary(sums, counter)
images = images[:, time:].reshape((-1, 80, 160, 3))[:64]
samples = samples.reshape((-1, 80, 160, 3))[:64]
return gl, samples, images
def f_load():
try:
return load(sess, saver, checkpoint_dir, name)
except:
print("Loading weights via Keras")
T.load_weights(checkpoint_dir+"/T_weights.keras")
def f_save(step):
save(sess, saver, checkpoint_dir, step, name)
T.save_weights(checkpoint_dir+"/T_weights.keras", True)
def sampler(z, x):
video = np.zeros((128, 80, 160, 3))
print "Sampling..."
for i in range(128):
print i
x = x.reshape((-1, 80, 160, 3))
# code = E.predict(x, batch_size=batch_size*(time+1))[0]
code = sess.run([E(I)[0]], feed_dict={I: x, Z: z, K.learning_phase(): 1})[0]
code = code.reshape((batch_size, time+out_leng, z_dim))
inp = np.concatenate([z, code], axis=-1)
outs = T.predict(inp, batch_size=batch_size) # [:, :out_leng, :]
# imgs = G.predict(out, batch_size=batch_size)
imgs = sess.run([G_dec], feed_dict={out: outs, Z: z, K.learning_phase(): 1})[0]
video[i] = imgs[0]
x = x.reshape((batch_size, time+out_leng, 80, 160, 3))
x[0, :-1] = x[0, 1:]
x[0, -1] = imgs[0]
z[0, :-1] = z[0, 1:]
video = video.reshape((batch_size, 2, 80, 160, 3))
return video[:, 0], video[:, 1]
G.load_weights(G_file_path)
E.load_weights(E_file_path)
return train_g, train_d, sampler, f_save, f_load, [G, E, T]
(-1, settings['image_size'][0], settings['image_size'][1],
settings['num_channels'])).astype(np.float32)
train_labels = to_categorical(train_labels)
valid_dataset = valid_dataset.reshape(
(-1, settings['image_size'][0], settings['image_size'][1],
settings['num_channels'])).astype(np.float32)
valid_labels_oh = to_categorical(valid_labels)
print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels_oh.shape)
input_img = Input(shape=(settings['image_size'][0],
settings['image_size'][1],
settings['num_channels']))
encode = encoder(input_img)
full_model = Model(input_img, fc(encode))
autoencoder = Model(input_img, decoder(encoder(input_img)))
autoencoder.load_weights('autoencoder.h5')
plot_model(autoencoder,
to_file='./img/autoencoder.eps',
show_shapes=True,
show_layer_names=False)
for l1, l2 in zip(full_model.layers[:12], autoencoder.layers[:12]):
l1.set_weights(l2.get_weights())
for layer in full_model.layers[:12]:
layer.trainable = False
def main(args=None):
"""Train an autoencoder model from `LightCurve` objects saved in
`args.survey_files`.
args: dict
Dictionary of values to override default values in `keras_util.parse_model_args`;
can also be passed via command line. See `parse_model_args` for full list of
possible arguments.
"""
args = ku.parse_model_args(args)
np.random.seed(0)
K.set_floatx('float64')
run = ku.get_run_id(**vars(args))
if not args.survey_files:
raise ValueError("No survey files given")
lc_lists = [joblib.load(f) for f in args.survey_files]
n_reps = [max(len(y) for y in lc_lists) // len(x) for x in lc_lists]
combined = sum([x * i for x, i in zip(lc_lists, n_reps)], [])
# Preparation for classification probability
classprob_pkl = joblib.load("./data/asassn/class_probs.pkl")
class_probability = dict(classprob_pkl)
# Combine subclasses into eight superclasses:
# CEPH, DSCT, ECL, RRAB, RRCD, M, ROT, SR
for lc in combined:
if ((lc.label == 'EW') or (lc.label == 'EA') or (lc.label == 'EB')):
lc.label = 'ECL'
if ((lc.label == 'CWA') or (lc.label == 'CWB') or (lc.label == 'DCEP') or
(lc.label == 'DCEPS') or (lc.label == 'RVA')):
lc.label = "CEPH"
if ((lc.label == 'DSCT') or (lc.label == 'HADS')):
lc.label = "DSCT"
if ((lc.label == 'RRD') or (lc.label == 'RRC')):
lc.label = "RRCD"
top_classes = ['SR', 'RRAB', 'RRCD', 'M', 'ROT', 'ECL', 'CEPH', 'DSCT']
print ("Number of raw LCs:", len(combined))
if args.lomb_score:
combined = [lc for lc in combined if lc.best_score >= args.lomb_score]
if args.ss_resid:
combined = [lc for lc in combined if lc.ss_resid <= args.ss_resid]
if args.class_prob:
combined = [lc for lc in combined if float(class_probability[lc.name.split("/")[-1][2:-4]]) >= args.class_prob]
#combined = [lc for lc in combined if lc.class_prob >= args.class_prob]
# Select only superclasses for training
combined = [lc for lc in combined if lc.label in top_classes]
split = [el for lc in combined for el in lc.split(args.n_min, args.n_max)]
if args.period_fold:
for lc in split:
lc.period_fold()
X_list = [np.c_[lc.times, lc.measurements, lc.errors] for lc in split]
classnames, indices = np.unique([lc.label for lc in split], return_inverse=True)
y = classnames[indices]
periods = np.array([np.log10(lc.p) for lc in split])
periods = periods.reshape(len(split), 1)
X_raw = pad_sequences(X_list, value=np.nan, dtype='float64', padding='post')
model_type_dict = {'gru': GRU, 'lstm': LSTM, 'vanilla': SimpleRNN}
X, means, scales, wrong_units, X_err = preprocess(X_raw, args.m_max)
y = y[~wrong_units]
periods = periods[~wrong_units]
# Prepare the indices for training and validation
train, valid = list(StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED).split(X, y))[0]
X_valid = X[valid]
y_valid = y[valid]
means_valid = means[valid]
scales_valid = scales[valid]
periods_valid = periods[valid]
energy_dummy_valid = np.zeros((X_valid.shape[0], 1))
X_err_valid = X_err[valid]
sample_weight_valid = 1. / X_err_valid
X = X[train]
y = y[train]
means = means[train]
scales = scales[train]
periods = periods[train]
energy_dummy = np.zeros((X.shape[0], 1))
X_err = X_err[train]
sample_weight = 1. / X_err
supports_valid = np.concatenate((means_valid, scales_valid, periods_valid), axis=1)
supports = np.concatenate((means, scales, periods), axis=1)
num_supports_train = supports.shape[-1]
num_supports_valid = supports_valid.shape[-1]
assert(num_supports_train == num_supports_valid)
num_additional = num_supports_train + 2 # 2 for reconstruction error
if (args.gmm_on):
gmm = GMM(args.num_classes, args.embedding+num_additional)
### Covert labels into one-hot vectors for training
label_encoder = LabelEncoder()
label_encoder.fit(y)
### Transform the integers into one-hot vector for softmax
train_y_encoded = label_encoder.transform(y)
train_y = np_utils.to_categorical(train_y_encoded)
### Repeat for validation dataset
label_encoder = LabelEncoder()
label_encoder.fit(y_valid)
### Transform the integers into one-hot vector for softmax
valid_y_encoded = label_encoder.transform(y_valid)
valid_y = np_utils.to_categorical(valid_y_encoded)
main_input = Input(shape=(X.shape[1], 2), name='main_input') # dim: (200, 2) = dt, mag
aux_input = Input(shape=(X.shape[1], 1), name='aux_input') # dim: (200, 1) = dt's
model_input = [main_input, aux_input]
if (args.gmm_on):
support_input = Input(shape=(num_supports_train,), name='support_input')
model_input = [main_input, aux_input, support_input]
encode = encoder(main_input, layer=model_type_dict[args.model_type],
output_size=args.embedding, **vars(args))
decode = decoder(encode, num_layers=args.decode_layers if args.decode_layers
else args.num_layers,
layer=model_type_dict[args.decode_type if args.decode_type
else args.model_type],
n_step=X.shape[1], aux_input=aux_input,
**{k: v for k, v in vars(args).items() if k != 'num_layers'})
optimizer = Adam(lr=args.lr if not args.finetune_rate else args.finetune_rate)
if (not args.gmm_on):
model = Model(model_input, decode)
model.compile(optimizer=optimizer, loss='mse',
sample_weight_mode='temporal')
else:
est_net = EstimationNet(args.estnet_size, args.num_classes, K.tanh)
# extract x_i and hat{x}_{i} for reconstruction error feature calculations
main_input_slice = Lambda(lambda x: x[:,:,1], name="main_slice")(main_input)
decode_slice = Lambda(lambda x: x[:,:,0], name="decode_slice")(decode)
z_both = Lambda(extract_features, name="concat_zs")([main_input_slice, decode_slice, encode, support_input])
gamma = est_net.inference(z_both, args.estnet_drop_frac)
print ("z_both shape", z_both.shape)
print ("gamma shape", gamma.shape)
sigma_i = Lambda(lambda x: gmm.fit(x[0], x[1]),
output_shape=(args.num_classes, args.embedding+num_additional, args.embedding+num_additional),
name="sigma_i")([z_both, gamma])
energy = Lambda(lambda x: gmm.energy(x[0], x[1]), name="energy")([z_both, sigma_i])
model_output = [decode, gamma, energy]
model = Model(model_input, model_output)
optimizer = Adam(lr=args.lr if not args.finetune_rate else args.finetune_rate)
model.compile(optimizer=optimizer,
loss=['mse', 'categorical_crossentropy', energy_loss],
loss_weights=[1.0, 1.0, args.lambda1],
metrics={'gamma':'accuracy'},
sample_weight_mode=['temporal', None, None])
# summary for checking dimensions
print(model.summary())
if (args.gmm_on):
history = ku.train_and_log( {'main_input':X, 'aux_input':np.delete(X, 1, axis=2), 'support_input':supports},
{'time_dist':X[:, :, [1]], 'gamma':train_y, 'energy':energy_dummy}, run, model,
sample_weight={'time_dist':sample_weight, 'gamma':None, 'energy':None},
validation_data=(
{'main_input':X_valid, 'aux_input':np.delete(X_valid, 1, axis=2), 'support_input':supports_valid},
{'time_dist':X_valid[:, :, [1]], 'gamma':valid_y, 'energy':energy_dummy_valid},
{'time_dist':sample_weight_valid, 'gamma':None, 'energy':None}),
**vars(args))
else: # Just train RNN autoencoder
history = ku.train_and_log({'main_input':X, 'aux_input':np.delete(X, 1, axis=2)},
X[:, :, [1]], run, model,
sample_weight=sample_weight,
validation_data=(
{'main_input':X_valid, 'aux_input':np.delete(X_valid, 1, axis=2)},
X_valid[:, :, [1]], sample_weight_valid), **vars(args))
return X, X_raw, model, means, scales, wrong_units, args
def main(argv):
#Get command line arguments
inputFile, inputLabels, testFile, testLabels, encModel, readUpto, testUpto, outputFile = getCommandLineArgs(
argv)
#Get hyperparameters
numConvLay, sizeConvFil, numConvFilPerLay, numNodes, epochs, batchSize = getExecParameters(
)
# Open files
inputFile = open(inputFile, "rb")
inputLabels = open(inputLabels, "rb")
testFile = open(testFile, "rb")
testLabels = open(testLabels, "rb")
# Get headers
magicnumber1, numImages, numrows, numcols = getIdxHeaders(inputFile)
magicnumber2, numImages2 = getIdxHeaders2(inputLabels)
magicnumber3, numImagesTest, numrowsTrain, numcolsTrain = getIdxHeaders(
testFile)
magicnumber4, numImagesTest2 = getIdxHeaders2(testLabels)
# Small check
if numImages != numImages2:
print("Size of train file and label file do not match!")
sys.exit()
# Small check
if numImagesTest != numImagesTest2:
print("Size of train file and label file do not match!")
sys.exit()
# Small check
if (numrows != numrowsTrain) or (numcols != numcolsTrain):
print(
"Image size in training file is not equal to image size in test file!"
)
sys.exit()
'''
print(magicnumber1, numImages, numrows, numcols)
print(magicnumber2, numImages2)
print(magicnumber3, numImagesTest, numrowsTrain, numcolsTrain)
print(magicnumber4, numImagesTest2)
'''
# Small check
if (readUpto is None) or (readUpto > numImages):
readUpto = numImages
# Small check
if (testUpto is None) or (testUpto > numImagesTest):
testUpto = numImagesTest
#
# Scan images from training set
#
img = Image(numrows, numcols)
images = []
train_images = np.zeros([readUpto, numrows, numcols])
print("Scanning training images...")
for i in range(readUpto):
img.scan(inputFile, i)
images.append(copy.deepcopy(img))
train_images[i] = copy.deepcopy(img.pixels)
train_images_original = train_images
print(readUpto, "training images scanned!")
#
# Scan labels from training set
#
train_labels = np.zeros(readUpto, dtype=np.uint8)
print("Scanning training labels...")
for i in range(readUpto):
b = inputLabels.read(1)
train_labels[i] = int(int.from_bytes(b, "big"))
print(readUpto, "training labels scanned!")
'''
# Print
for i in range(readUpto):
print("Label =", train_labels[i])
images[i].print()
print('')
'''
# Convert to one-hot encoding
one_hot_train_labels = keras.utils.to_categorical(train_labels)
#
# Scan images from test set
#
img = Image(numrows, numcols)
images2 = []
test_images = np.zeros([testUpto, numrows, numcols])
print("Scanning testing images...")
for i in range(testUpto):
img.scan(testFile, i)
images2.append(copy.deepcopy(img))
test_images[i] = copy.deepcopy(img.pixels)
print(readUpto, "testing images scanned!")
#
# Scan labels from test set
#
test_labels = np.zeros(testUpto, dtype=np.uint8)
print("Scanning testing labels...")
for i in range(testUpto):
b = testLabels.read(1)
test_labels[i] = int(int.from_bytes(b, "big"))
print(readUpto, "testing labels scanned!")
'''
# Print
for i in range(testUpto):
print("Label =", test_labels[i])
images2[i].print()
print('')
'''
# Convert to one-hot encoding
one_hot_test_labels = keras.utils.to_categorical(test_labels)
#
# Set up classificator model
#
# Define input shape
input_img = keras.Input(shape=(numrows, numcols, 1))
# Load autoencoder weights
tempModel = models.Model(
input_img,
decoder(encoder(input_img, numConvLay, sizeConvFil, numConvFilPerLay),
numConvLay, sizeConvFil, numConvFilPerLay))
tempModel.compile(loss='mean_squared_error',
optimizer=optimizers.RMSprop())
tempModel.load_weights(encModel)
# Define classificatior model
classifier = models.Model(
input_img,
fullyConnected(
encoder(input_img, numConvLay, sizeConvFil, numConvFilPerLay),
numNodes))
# Set weights in new model
trainedLayers = numConvLay * (2 * numConvFilPerLay + 1) + 1
for l1, l2 in zip(classifier.layers[:trainedLayers],
tempModel.layers[0:trainedLayers]):
l1.set_weights(l2.get_weights())
'''
# Check validity of weights
print("\n\nWeights #1")
print(tempModel.get_weights()[0][1])
print("\n\nWeights #2")
print(classifier.get_weights()[0][1])
'''
# Set already trained weights to non trainable
for layer in classifier.layers[0:trainedLayers]:
layer.trainable = False
# Compile classifier
classifier.compile(loss=losses.categorical_crossentropy,
optimizer=optimizers.Adam(),
metrics=['accuracy'])
# Print summary
print(classifier.summary())
# Split train data
from sklearn.model_selection import train_test_split
train_images, validation_images, train_labels, validation_labels = train_test_split(
train_images, one_hot_train_labels, test_size=0.2, random_state=13)
# Train the model
history = classifier.fit(train_images,
train_labels,
batch_size=batchSize,
epochs=epochs,
verbose=1,
validation_data=(validation_images,
validation_labels))
'''
# Plot
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
'''
# Re train the whole model
for layer in classifier.layers[0:trainedLayers]:
layer.trainable = True
classifier.compile(loss=losses.categorical_crossentropy,
optimizer=optimizers.Adam(),
metrics=['accuracy'])
history2 = classifier.fit(train_images,
train_labels,
batch_size=batchSize,
epochs=epochs,
verbose=1,
validation_data=(validation_images,
validation_labels))
# Plot
plt.plot(history2.history['loss'])
plt.plot(history2.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
# Predict some stuff
predictions = classifier.predict(test_images)
predictions = np.argmax(np.round(predictions), axis=1)
# Print stats
print('')
from sklearn.metrics import classification_report
target_names = ["Class {}".format(i) for i in range(10)]
print(
classification_report(test_labels,
predictions,
target_names=target_names))
ans = input("Print some extra stats? (y/n) ...")
if ans == "y":
# Calculate correct labels
correct = np.where(predictions == test_labels, predictions, -1)
asdf = np.where(correct != -1)[0]
print("\nFound", len(asdf), " correct labels")
# Print first 10 correct
j = 0
print("Printing first 10 correct...")
for i, c in enumerate(correct):
if c != -1:
print("correct[i] =", correct[i], ", test_labels[i] =",
test_labels[i])
j += 1
if j == 10:
break
# Calculate incorrect labels
incorrect = np.where(predictions != test_labels, predictions, -1)
asdf2 = np.where(incorrect != -1)[0]
print("\nFound", len(asdf2), " incorrect labels")
# Print first 10 icorrect
j = 0
print("Printing first 10 incorrect...")
for i, c in enumerate(incorrect):
if c != -1:
print("incorrect[i] =", incorrect[i], ", test_labels[i] =",
test_labels[i])
j += 1
if j == 10:
break
predictions = classifier.predict(train_images_original)
predictions = np.argmax(np.round(predictions), axis=1)
write_predictions(predictions, outputFile)
def main(args):
X_train, Y_train = load_data(args.data)
Y_train_ = np.stack([Y_train.squeeze()] * 3, axis=3)
# X_train_bw = (np.sum(X_train, axis=3)/(3)).reshape([-1,245,437,1])
if args.GPU == 0:
config = tf.ConfigProto(device_count={'GPU': 0})
else:
config = tf.ConfigProto()
config.gpu_options.allow_growth = False
tf.reset_default_graph()
if args.data == 0:
X = tf.placeholder(tf.float32, [None, 480, 640, 3])
Y = tf.placeholder(tf.float32, [None, 480, 640, 1])
elif args.data == 1:
X = tf.placeholder(tf.float32, [None, 245, 437, 3])
X_ = tf.placeholder(tf.float32, [None, 245, 437, 1])
Y = tf.placeholder(tf.float32, [None, 245, 437, 1])
is_training = tf.placeholder(tf.bool)
with tf.variable_scope('Encoder') as enc:
latent_y = encoder(X, is_training, args.data)
with tf.variable_scope('Decoder') as dec:
output = decoder(latent_y, is_training, args.data)
with tf.variable_scope('Loss_Encoder') as ln:
y_feats = autoencoder.encoder(output, is_training, args.data)
with tf.variable_scope(ln, reuse=True):
x_feats = autoencoder.encoder(Y, is_training, args.data)
trans_loss = l1_norm(output - Y)
reg_loss = TV_loss(output)
feat_loss = gram_loss(y_feats[0], x_feats[0])
feat_loss += gram_loss(y_feats[1], x_feats[1])
feat_loss += gram_loss(y_feats[2], x_feats[2])
feat_loss += gram_loss(y_feats[3], x_feats[3])
# feat_loss = tf.nn.l2_loss(y_feats[0] - x_feats[0])
# feat_loss += tf.nn.l2_loss(y_feats[1] - x_feats[1])
# feat_loss += tf.nn.l2_loss(y_feats[2] - x_feats[2])
# feat_loss += tf.nn.l2_loss(y_feats[3] - x_feats[3])
# mean_loss = tf.reduce_mean(trans_loss + args.lam*feat_loss)
mean_loss = tf.reduce_mean(trans_loss + 0.1 * reg_loss + 10.0 * feat_loss)
tf.summary.scalar('loss', mean_loss)
optimizer = tf.train.AdamOptimizer(learning_rate=args.rate)
extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
enc_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='Encoder')
dec_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='Decoder')
loss_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='Loss_Encoder')
with tf.control_dependencies(extra_update_ops):
train_full = optimizer.minimize(mean_loss,
var_list=[enc_vars, dec_vars])
sess = tf.Session(config=config)
enc_saver = tf.train.Saver(var_list=enc_vars)
dec_saver = tf.train.Saver(var_list=dec_vars)
loss_saver = tf.train.Saver(var_list=loss_vars)
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter('./tb', sess.graph)
sess.run(tf.global_variables_initializer())
loss_saver.restore(sess, './loss_network/loss_network_enc')
enc_saver.restore(sess, './trained_model/initial_model_enc')
dec_saver.restore(sess, './trained_model/initial_model_dec')
_ = run_model(sess,
X,
X_,
Y,
is_training,
mean_loss,
X_train,
Y_train,
Y_train,
epochs=args.epochs,
batch_size=args.batch_size,
print_every=10,
training=train_full,
plot_losses=False,
writer=writer,
sum_vars=merged)
model_name = './trained_model/final_model'
# model_name += 'data_' + str(args.data)
# model_name += '_epochs_' + str(args.epochs)
# model_name += '_batchsize_' + str(args.batch_size)
# model_name += '_rate_' + str(args.rate)
enc_saver.save(sess, model_name + '_enc')
dec_saver.save(sess, model_name + '_dec')
def main(args=None):
args = ku.parse_model_args(args)
args.loss = 'categorical_crossentropy'
np.random.seed(0)
if not args.survey_files:
raise ValueError("No survey files given")
classes = [
'RR_Lyrae_FM', 'W_Ursae_Maj', 'Classical_Cepheid', 'Beta_Persei',
'Semireg_PV'
]
lc_lists = [joblib.load(f) for f in args.survey_files]
combined = [lc for lc_list in lc_lists for lc in lc_list]
combined = [lc for lc in combined if lc.label in classes]
if args.lomb_score:
combined = [lc for lc in combined if lc.best_score >= args.lomb_score]
split = [el for lc in combined for el in lc.split(args.n_min, args.n_max)]
if args.period_fold:
for lc in split:
lc.period_fold()
X_list = [np.c_[lc.times, lc.measurements, lc.errors] for lc in split]
classnames, y_inds = np.unique([lc.label for lc in split],
return_inverse=True)
Y = to_categorical(y_inds, len(classnames))
X_raw = pad_sequences(X_list, value=np.nan, dtype='float', padding='post')
X, means, scales, wrong_units = preprocess(X_raw, args.m_max)
Y = Y[~wrong_units]
# Remove errors
X = X[:, :, :2]
if args.even:
X = X[:, :, 1:]
# shuffled_inds = np.random.permutation(np.arange(len(X)))
# train = np.sort(shuffled_inds[:args.N_train])
# valid = np.sort(shuffled_inds[args.N_train:])
train, valid = list(
StratifiedKFold(n_splits=5, shuffle=True,
random_state=0).split(X_list, y_inds))[0]
model_type_dict = {
'gru': GRU,
'lstm': LSTM,
'vanilla': SimpleRNN,
'conv': Conv1D
} #, 'atrous': AtrousConv1D, 'phased': PhasedLSTM}
# if args.pretrain:
# auto_args = {k: v for k, v in args.__dict__.items() if k != 'pretrain'}
# auto_args['sim_type'] = args.pretrain
## auto_args['no_train'] = True
# auto_args['epochs'] = 1; auto_args['loss'] = 'mse'; auto_args['batch_size'] = 32; auto_args['sim_type'] = 'test'
# _, _, auto_model, _ = survey_autoencoder(auto_args)
# for layer in auto_model.layers:
# layer.trainable = False
# model_input = auto_model.input[0]
# encode = auto_model.get_layer('encoding').output
# else:
# model_input = Input(shape=(X.shape[1], X.shape[-1]), name='main_input')
# encode = encoder(model_input, layer=model_type_dict[args.model_type],
# output_size=args.embedding, **vars(args))
model_input = Input(shape=(X.shape[1], X.shape[-1]), name='main_input')
encode = encoder(model_input,
layer=model_type_dict[args.model_type],
output_size=args.embedding,
**vars(args))
scale_param_input = Input(shape=(2, ), name='scale_params')
merged = merge([encode, scale_param_input], mode='concat')
out = Dense(args.size + 2, activation='relu')(merged)
out = Dense(Y.shape[-1], activation='softmax')(out)
model = Model([model_input, scale_param_input], out)
run = ku.get_run_id(**vars(args))
if args.pretrain:
for layer in model.layers:
layer.trainable = False
pretrain_weights = os.path.join('keras_logs', args.pretrain, run,
'weights.h5')
else:
pretrain_weights = None
history = ku.train_and_log(
[X[train], np.c_[means, scales][train]],
Y[train],
run,
model,
metrics=['accuracy'],
validation_data=([X[valid], np.c_[means, scales][valid]], Y[valid]),
pretrain_weights=pretrain_weights,
**vars(args))
return X, X_raw, Y, model, args
testLabel = dfLabel.iloc[~mask, 1].values # simply impute missing data with mean value from sklearn.preprocessing import Imputer fill_NaN = Imputer(missing_values=np.nan, strategy='mean', axis=1) imptrainData = pd.DataFrame(fill_NaN.fit_transform(trainData)) imptestData = pd.DataFrame(fill_NaN.fit_transform(testData)) # normalize features nortrainData = (imptrainData - imptrainData.mean()) / imptrainData.std() nortestData = (imptestData - imptestData.mean()) / imptestData.std() #%% reduce feature dimension by autoencoder from autoencoder import encoder output_train, output_test = encoder(nortrainData, nortestData) #%%%%%%%%%%%%%%%% use gbm ############# from sklearn.ensemble import GradientBoostingClassifier #GBM algorithm from sklearn.grid_search import GridSearchCV #Performing grid search from gbmModel import modelfit from gbmModel import modelvali #All of the rc settings are stored in a dictionary-like variable called matplotlib.rcParams from matplotlib.pylab import rcParams rcParams['figure.figsize'] = 12, 4 gbm0 = GradientBoostingClassifier(random_state=10) #gbm_tuned = GradientBoostingClassifier(learning_rate=0.005, n_estimators=1200,max_depth=9, min_samples_split=1200, min_samples_leaf=60, subsample=0.85, random_state=10, max_features=7,warm_start=True) alggbm = modelfit(gbm0, output_train, trainLabel) #%%
def classification(trainSet, trainLabelsSet, testSet, testLabelsSet,
autoencoderPath, layers, fcNodes, batchSize, epochs):
trainImages = []
with open(trainSet, "rb") as f:
magicNum = int.from_bytes(f.read(4), byteorder="big")
numOfImages = int.from_bytes(f.read(4), byteorder="big")
dx = int.from_bytes(f.read(4), byteorder="big")
dy = int.from_bytes(f.read(4), byteorder="big")
dimensions = dx * dy
# https://www.kaggle.com/hojjatk/read-mnist-dataset
buf = f.read(dimensions * numOfImages)
trainImages = np.frombuffer(buf, dtype=np.uint8).astype(np.float32)
trainImages = trainImages.reshape(numOfImages, dx, dy)
trainImages = np.array(trainImages).reshape(-1, dx, dy,
1).astype('float32') / 255.
testImages = []
with open(testSet, "rb") as f:
magicNum = int.from_bytes(f.read(4), byteorder="big")
numOfImages = int.from_bytes(f.read(4), byteorder="big")
dx = int.from_bytes(f.read(4), byteorder="big")
dy = int.from_bytes(f.read(4), byteorder="big")
dimensions = dx * dy
# https://www.kaggle.com/hojjatk/read-mnist-dataset
buf = f.read(dimensions * numOfImages)
testImages = np.frombuffer(buf, dtype=np.uint8).astype(np.float32)
testImages = testImages.reshape(numOfImages, dx, dy)
testImages = np.array(testImages).reshape(-1, dx, dy,
1).astype('float32') / 255.
trainLabels = []
with open(trainLabelsSet, "rb") as f:
magicNum = int.from_bytes(f.read(4), byteorder="big")
numOfImages = int.from_bytes(f.read(4), byteorder="big")
buf = f.read(1 * numOfImages)
trainLabels = np.frombuffer(buf, dtype=np.uint8).astype(np.int64)
trainLabels = np.array(trainLabels)
testLabels = []
with open(testLabelsSet, "rb") as f:
magicNum = int.from_bytes(f.read(4), byteorder="big")
numOfImages = int.from_bytes(f.read(4), byteorder="big")
# https://www.kaggle.com/hojjatk/read-mnist-dataset
buf = f.read(1 * numOfImages)
testLabels = np.frombuffer(buf, dtype=np.uint8).astype(np.int64)
testLabels = np.array(testLabels)
#conversion to one-hot arrays
trainCatLabels = to_categorical(trainLabels)
testCatLabels = to_categorical(testLabels)
inChannel = 1
inputImage = Input(shape=(dx, dy, inChannel))
xTrain, xValid, trainLabel, validLabel = train_test_split(trainImages,
trainCatLabels,
test_size=0.2,
random_state=13)
autoencoder = keras.models.load_model(autoencoderPath)
if layers != (int(len(autoencoder.layers) / 2) - 1):
sys.exit(
"We are sorry to announce that no encoder exists with the given number of layers in your autoencoder. Please try again."
)
# autoencoderWeights = autoencoder.load_weights('./autoencoderWeights.h5')
encode = encoder(inputImage, layers)
fullModel = Model(inputImage, fullyConnected(encode, fcNodes))
for l1, l2 in zip(fullModel.layers[:layers], autoencoder.layers[0:layers]):
l1.set_weights(l2.get_weights())
for layer in fullModel.layers[0:(int(len(autoencoder.layers) / 2) - 1)]:
layer.trainable = False
keras.callbacks.EarlyStopping(monitor='loss',
min_delta=0,
patience=2,
verbose=0,
mode='auto')
keras.callbacks.EarlyStopping(monitor='accuracy',
min_delta=0,
patience=2,
verbose=0,
mode='auto')
keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=0,
patience=2,
verbose=0,
mode='auto')
keras.callbacks.EarlyStopping(monitor='val_accuracy',
min_delta=0,
patience=2,
verbose=0,
mode='auto')
fullModel.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
classifyTrain = fullModel.fit(xTrain,
trainLabel,
batch_size=batchSize,
epochs=epochs,
verbose=1,
validation_data=(xValid, validLabel))
fullModel.save_weights('autoencoderClassification.h5')
for layer in fullModel.layers[0:(int(len(autoencoder.layers) / 2) - 1)]:
layer.trainable = True
fullModel.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
classifyTrain = fullModel.fit(xTrain,
trainLabel,
batch_size=batchSize,
epochs=epochs,
verbose=1,
validation_data=(xValid, validLabel))
fullModel.save_weights('classificationComplete.h5')
testEval = fullModel.evaluate(testImages, testCatLabels, verbose=0)
predictedClasses = fullModel.predict(testImages)
predictedClasses = np.argmax(np.round(predictedClasses), axis=1)
inp = input(
"We have produced the classification model. Would you like to start with predictions? (Y/n) "
)
if inp == 'Y' or inp == 'y':
print("Started making predictions...")
correct = np.where(predictedClasses == testLabels)[0]
print("Found " + str(len(correct)) + " correct labels")
for i, correct in enumerate(correct[:12]):
plt.subplot(4, 3, i + 1)
plt.imshow(testImages[correct].reshape(28, 28),
cmap='gray',
interpolation='none')
plt.title("Predicted {}, Class {}".format(
predictedClasses[correct], testLabels[correct]))
plt.tight_layout()
plt.savefig('correctPredictions.png')
plt.savefig('correctPredictions.png', bbox_inches='tight')
plt.show()
incorrect = np.where(predictedClasses != testLabels)[0]
print("Found " + str(len(incorrect)) + " incorrect labels")
plt.figure()
for i, incorrect in enumerate(incorrect[:12]):
plt.subplot(4, 3, i + 1)
plt.imshow(testImages[incorrect].reshape(28, 28),
cmap='gray',
interpolation='none')
plt.title("Predicted {}, Class {}".format(
predictedClasses[incorrect], testLabels[incorrect]))
plt.tight_layout()
plt.savefig('incorrectPredictions.png')
plt.savefig('incorrectPredictions.png', bbox_inches='tight')
plt.show()
print("More specifically:\n")
print(classification_report(testLabels, predictedClasses))
inp = input(
"Would you like to plot your experiment's loss and accuracy results? (Y/n) "
)
if inp == 'Y' or inp == 'y':
accuracy = classifyTrain.history['accuracy']
val_accuracy = classifyTrain.history['val_accuracy']
loss = classifyTrain.history['loss']
val_loss = classifyTrain.history['val_loss']
epochs = range(len(accuracy))
plt.plot(epochs, accuracy, 'bo', label='Training accuracy')
plt.plot(epochs, val_accuracy, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.savefig('overfittingClassCheck.png')
plt.savefig('overfittingClassCheck.png', bbox_inches='tight')
plt.show()
# return 0
inp = input(
"Would you like to repeat your experiment with different hyperparameter values? (Y/n) "
)
if inp == 'Y' or inp == 'y':
return 1
return 0
def main(args=None):
"""Train an autoencoder model from `LightCurve` objects saved in
`args.survey_files`.
args: dict
Dictionary of values to override default values in `keras_util.parse_model_args`;
can also be passed via command line. See `parse_model_args` for full list of
possible arguments.
"""
args = ku.parse_model_args(args)
np.random.seed(0)
if not args.survey_files:
raise ValueError("No survey files given")
lc_lists = [joblib.load(f) for f in args.survey_files]
n_reps = [max(len(y) for y in lc_lists) // len(x) for x in lc_lists]
combined = sum([x * i for x, i in zip(lc_lists, n_reps)], [])
if args.lomb_score:
combined = [lc for lc in combined if lc.best_score >= args.lomb_score]
if args.ss_resid:
combined = [lc for lc in combined if lc.ss_resid <= args.ss_resid]
split = [el for lc in combined for el in lc.split(args.n_min, args.n_max)]
if args.period_fold:
for lc in split:
lc.period_fold()
X_list = [np.c_[lc.times, lc.measurements, lc.errors] for lc in split]
X_raw = pad_sequences(X_list, value=np.nan, dtype='float', padding='post')
model_type_dict = {'gru': GRU, 'lstm': LSTM, 'vanilla': SimpleRNN}
X, means, scales, wrong_units = preprocess(X_raw, args.m_max)
main_input = Input(shape=(X.shape[1], X.shape[-1]), name='main_input')
aux_input = Input(shape=(X.shape[1], X.shape[-1] - 1), name='aux_input')
model_input = [main_input, aux_input]
encode = encoder(main_input,
layer=model_type_dict[args.model_type],
output_size=args.embedding,
**vars(args))
decode = decoder(
encode,
num_layers=args.decode_layers
if args.decode_layers else args.num_layers,
layer=model_type_dict[args.decode_type if args.decode_type else args.
model_type],
n_step=X.shape[1],
aux_input=aux_input,
**{k: v
for k, v in vars(args).items() if k != 'num_layers'})
model = Model(model_input, decode)
run = ku.get_run_id(**vars(args))
errors = X_raw[:, :, 2] / scales
sample_weight = 1. / errors
sample_weight[np.isnan(sample_weight)] = 0.0
X[np.isnan(X)] = 0.
history = ku.train_and_log(
{
'main_input': X,
'aux_input': np.delete(X, 1, axis=2)
},
X[:, :, [1]],
run,
model,
sample_weight=sample_weight,
errors=errors,
validation_split=0.0,
**vars(args))
return X, X_raw, model, means, scales, wrong_units, args
def classification_model(X, drop_out_prob = 0.8):
layer_1 = encoder(X,drop_prob = drop_out_prob)
layer_1_norm = tf.layers.batch_normalization(layer_1, center = True, scale = True)
scores = tf.add(tf.matmul(layer_1_norm, W1), b1)
prediction = tf.nn.softmax(scores)
return prediction
def get_model(sess, image_shape=(80, 160, 3), gf_dim=64, df_dim=64, batch_size=64,
name="transition", gpu=0):
K.set_session(sess)
checkpoint_dir = './outputs/results_' + name
with tf.variable_scope(name):
# sizes
ch = image_shape[2]
rows = [image_shape[0]/i for i in [16, 8, 4, 2, 1]]
cols = [image_shape[1]/i for i in [16, 8, 4, 2, 1]]
G = autoencoder.generator(7*(time+out_leng-1), gf_dim, ch, rows, cols)
G.compile("sgd", "mse")
E = autoencoder.encoder(batch_size*(time+out_leng), df_dim, ch, rows, cols)
E.compile("sgd", "mse")
G.trainable = False
E.trainable = False
# nets
T = transition(batch_size)
T.compile("sgd", "mse")
t_vars = T.trainable_weights
print "T.shape: ", T.output_shape
Img = Input(batch_shape=(batch_size, time+out_leng,) + image_shape)
I = K.reshape(Img, (batch_size*(time+out_leng),)+image_shape)
code = E(I)[0]
code = K.reshape(code, (batch_size, time+out_leng, z_dim))
target = code[:, 1:, :]
inp = code[:, :time, :]
out = T(inp)
G_dec = G(K.reshape(out[:7, :, :], (-1, z_dim)))
# costs
loss = tf.reduce_mean(tf.square(target - out))
print "Transition variables:"
for v in t_vars:
print v.name
t_optim = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(loss, var_list=t_vars)
tf.initialize_all_variables().run()
# summaries
sum_loss = tf.scalar_summary("loss", loss)
sum_e_mean = tf.histogram_summary("e_mean", code)
sum_out = tf.histogram_summary("out", out)
sum_dec = tf.image_summary("E", G_dec)
# saver
saver = tf.train.Saver()
t_sum = tf.merge_summary([sum_e_mean, sum_out, sum_dec, sum_loss])
writer = tf.train.SummaryWriter("/tmp/logs/"+name, sess.graph)
# functions
def train_d(images, z, counter, sess=sess):
return 0, 0, 0
def train_g(images, z, counter, sess=sess):
outputs = [loss, G_dec, t_sum, t_optim]
outs = sess.run(outputs, feed_dict={Img: images, K.learning_phase(): 1})
gl, samples, sums = outs[:3]
writer.add_summary(sums, counter)
images = images.reshape((-1, 80, 160, 3))[:64]
samples = samples.reshape((-1, 80, 160, 3))[:64]
return gl, samples, images
def f_load():
try:
return load(sess, saver, checkpoint_dir, name)
except:
print("Loading weights via Keras")
T.load_weights(checkpoint_dir+"/T_weights.keras")
def f_save(step):
save(sess, saver, checkpoint_dir, step, name)
T.save_weights(checkpoint_dir+"/T_weights.keras", True)
def sampler(z, x):
video = np.zeros((128, 80, 160, 3))
print "Sampling..."
for i in range(128):
print i
x = x.reshape((-1, 80, 160, 3))
# code = E.predict(x, batch_size=batch_size*(time+1))[0]
code = sess.run([E(I)[0]], feed_dict={I: x, K.learning_phase(): 1})[0]
code = code.reshape((batch_size, time+out_leng, z_dim))
inp = code[:, :time]
outs = T.predict(inp, batch_size=batch_size)
# imgs = G.predict(out, batch_size=batch_size)
imgs = sess.run([G_dec], feed_dict={out: outs, K.learning_phase(): 1})[0]
video[i] = imgs[0]
x = x.reshape((batch_size, time+out_leng, 80, 160, 3))
x[0, :-1] = x[0, 1:]
x[0, -1] = imgs[0]
video = video.reshape((batch_size, 2, 80, 160, 3))
return video[:, 0], video[:, 1]
G.load_weights(G_file_path)
E.load_weights(E_file_path)
return train_g, train_d, sampler, f_save, f_load, [G, E, T]
(-1, settings['image_size'][0], settings['image_size'][1],
settings['num_channels'])).astype(np.float32)
train_labels = to_categorical(train_labels)
valid_dataset = valid_dataset.reshape(
(-1, settings['image_size'][0], settings['image_size'][1],
settings['num_channels'])).astype(np.float32)
valid_labels_oh = to_categorical(valid_labels)
print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels_oh.shape)
input_img = Input(shape=(settings['image_size'][0],
settings['image_size'][1],
settings['num_channels']))
encode = encoder(input_img)
full_model = Model(input_img, fc(encode))
full_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(lr=6e-5, decay=0.85e-7),
metrics=['accuracy'])
classify_train = full_model.fit(train_dataset,
train_labels,
batch_size=256,
epochs=600,
verbose=1,
validation_data=(valid_dataset,
valid_labels_oh))
full_model.save_weights('classification_complete_noauto.h5')
def main():
'''Configuration'''
parser = argparse.ArgumentParser()
parser.add_argument('--encoder', type=str)
parser.add_argument('--segmentation', type=str)
parser.add_argument('--discriminator', type=str)
parser.add_argument('--batch_size', type=int)
parser.add_argument('--LAMBDA', type=int)
parser.add_argument('--save_dir', type=str)
args = parser.parse_args()
LAMBDA = args.LAMBDA
batch_size = args.batch_size
learning_rate = 1e-4
num_epochs = 500
device = torch.device('cuda')
save_dir = args.save_dir
if os.path.exists(save_dir) == False:
os.mkdir(save_dir)
enc_path = args.encoder
dis_path = args.discriminator
seg_path = args.segmentation
'''Initialize dataset'''
train_set = ppmi_pairs(mode='train')
val_set = ppmi_pairs(mode='val')
'''Initialize networks'''
# init model encrypter
Encrypter = encoder(1, 1, 16).to(device)
if os.path.exists(enc_path):
Encrypter.load_state_dict(torch.load(enc_path, map_location=device))
Encrypter.train()
# init discriminator
Discriminator = discriminator().to(device)
if os.path.exists(dis_path):
Discriminator.load_state_dict(torch.load(dis_path,
map_location=device))
Discriminator.train()
# init segmentator
Segmentator = segnet(1, 6, 32).to(device)
if os.path.exists(seg_path):
Segmentator.load_state_dict(torch.load(seg_path, map_location=device))
Segmentator.train()
#
models = {'enc': Encrypter, 'seg': Segmentator, 'dis': Discriminator}
'''Initialize optimizer'''
# declare loss function
Segment_criterion = Dice_Loss()
Discrimination_criterion = torch.nn.CrossEntropyLoss()
criterions = {'seg': Segment_criterion, 'dis': Discrimination_criterion}
# init optimizer
params_es = [{
"params": Encrypter.parameters()
}, {
"params": Segmentator.parameters()
}]
optimizer_es = torch.optim.Adam(params_es, lr=learning_rate)
params_d = [{"params": Discriminator.parameters()}]
optimizer_d = torch.optim.Adam(params_d, lr=learning_rate)
optimizers = {'es': optimizer_es, 'dis': optimizer_d}
for epoch in range(num_epochs):
print('|==========================\nEPOCH:{}'.format(epoch + 1))
'''Trainnig'''
_, _, _, _,\
models, optimizers = train_epoch(models, optimizers, criterions, LAMBDA, train_set, batch_size,device)
'''Validation'''
if (epoch + 1) % 1 == 0:
val_epoch(models, criterions, val_set, batch_size, device)
#save model
if (epoch + 1) % 1 == 0:
'''save models'''
models_dir = os.path.join(save_dir, 'models')
if os.path.exists(models_dir) == False:
os.mkdir(models_dir)
torch.save(models['enc'].state_dict(),
os.path.join(models_dir, 'enc.pt'))
torch.save(models['seg'].state_dict(),
os.path.join(models_dir, 'seg.pt'))
torch.save(models['dis'].state_dict(),
os.path.join(models_dir, 'dis.pt'))
torch.save(optimizers['es'].state_dict(),
os.path.join(models_dir, 'optim_es.pt'))
torch.save(optimizers['dis'].state_dict(),
os.path.join(models_dir, 'optim_dis.pt'))
return