def main():
with CustomObjectScope(custom_objects()):
model = load_model(SAVED_MODEL)
img_in = misc.imread("data/border.jpg")
i_width = 224
i_height = 224
img_resize = skimage.transform.resize(img_in, (i_width, i_height),
preserve_range=True)
img = np.copy(img_resize).astype('uint8')
img_reshape = img.reshape(1, size, size, 3).astype(float)
t1 = time.time()
pred = model.predict(standardize(img_reshape)).reshape(size, size)
elapsed = time.time() - t1
print('elapsed1: ', elapsed)
plt.subplot(2, 2, 1)
plt.imshow(img)
plt.subplot(2, 2, 2)
plt.imshow(pred)
plt.show()
def main(img_file, weight_file):
model = MobileUNet(input_shape=(128, 128, 3), alpha=1, alpha_up=0.25)
model.summary()
model.load_weights(weight_file, by_name=True)
img = imread(img_file)
img = imresize(img, (img_size, img_size))
mask_file = re.sub('img2.jpg$', 'msk1.png', img_file)
mask = imread(mask_file)
mask = imresize(mask, (img_size, img_size))
batched1 = img.reshape(1, img_size, img_size, 3).astype(float)
pred1 = model.predict(standardize(batched1)).reshape(img_size, img_size)
if True:
plt.subplot(2, 2, 1)
plt.imshow(img)
plt.subplot(2, 2, 2)
plt.imshow(pred1)
plt.subplot(2, 2, 3)
plt.imshow(mask)
plt.show()
def test(model, train, test):
m = tf.keras.models.load_model(model)
x_test, y_test = data.load(test)
# normalize test set relative to the train set
x_train, y_train = data.load(train)
mean = np.mean(x_train, axis=(0,1,2))
std = np.std(x_train, axis=(0,1,2))
x_test = data.standardize(x_test, mean, std)
y_pred = m.predict(
x=x_test,
batch_size=32,
verbose=1,
)
# Keep raw probability scores
y_pred.reshape(-1)
y_scores = y_pred
# Threshold default predictions at 0.5
threshold = 0.5
y_pred[y_pred <= threshold] = 0. # not melanoma
y_pred[y_pred > threshold] = 1. # melanoma
np.savez_compressed(os.path.join(os.path.dirname(model), 'predictions'), y_true=y_test, y_pred=y_pred, y_scores=y_scores)
def main(pb_file, img_file):
"""
Predict and visualize by TensorFlow.
:param pb_file:
:param img_file:
:return:
"""
with tf.gfile.GFile(pb_file, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
with tf.Graph().as_default() as graph:
tf.import_graph_def(graph_def, name=prefix)
for op in graph.get_operations():
print(op.name)
x = graph.get_tensor_by_name('%s/input_1:0' % prefix)
y = graph.get_tensor_by_name('%s/output_0:0' % prefix)
images = np.load(img_file).astype(float)
img_h = images.shape[1]
img_w = images.shape[2]
with tf.Session(graph=graph) as sess:
for img in images:
batched = img.reshape(-1, img_h, img_w, 3)
normalized = standardize(batched)
pred = sess.run(y, feed_dict={
x: normalized
})
plt.imshow(pred.reshape(img_h, img_w))
plt.show()
def main():
with CustomObjectScope(custom_objects()):
model1 = load_model(SAVED_MODEL1)
model2 = load_model(SAVED_MODEL2)
images = np.load('data/images-224.npy')
masks = np.load('data/masks-224.npy')
# only hair
masks = masks[:, :, :, 0].reshape(-1, size, size)
_, images, _, masks = train_test_split(images,
masks,
test_size=0.2,
random_state=seed)
for img, mask in zip(images, masks):
batched1 = img.reshape(1, size, size, 3).astype(float)
batched2 = img.reshape(1, size, size, 3).astype(float)
t1 = time.time()
pred1 = model1.predict(standardize(batched1)).reshape(size, size)
elapsed = time.time() - t1
print('elapsed1: ', elapsed)
t1 = time.time()
pred2 = model2.predict(standardize(batched2)).reshape(size, size)
elapsed = time.time() - t1
print('elapsed2: ', elapsed)
dice = np_dice_coef(mask.astype(float) / 255, pred1)
print('dice1: ', dice)
dice = np_dice_coef(mask.astype(float) / 255, pred2)
print('dice2: ', dice)
if True:
plt.subplot(2, 2, 1)
plt.imshow(img)
plt.subplot(2, 2, 2)
plt.imshow(mask)
plt.subplot(2, 2, 3)
plt.imshow(pred1)
plt.subplot(2, 2, 4)
plt.imshow(pred2)
plt.show()
def save_dataset(dir_out, x, y, x_test, y_test, standardize=True):
if not os.path.exists(dir_out):
os.makedirs(dir_out)
if standardize:
x, y, x_test, y_test = data.standardize(x, y, x_test, y_test)
np.savetxt(os.path.join(dir_out, 'x.csv'), x)
np.savetxt(os.path.join(dir_out, 'y.csv'), y)
np.savetxt(os.path.join(dir_out, 'x_test.csv'), x_test)
np.savetxt(os.path.join(dir_out, 'y_test.csv'), y_test)
def main(img_dir, only_weight, img_size):
if only_weight != 0:
with CustomObjectScope(custom_objects()):
model = load_model(SAVED_MODEL)
print("loading model file: ", SAVED_MODEL, img_size)
else:
weight_file = SAVED_WEIGHT
model = MobileUNet(input_shape=(img_size, img_size, 3),
alpha=1,
alpha_up=0.25)
model.load_weights(weight_file, by_name=True)
print("loading weight file: ", weight_file, img_size)
model.summary()
img_files = glob(img_dir + '/*.jpg')
img_files = sorted(img_files, key=os.path.getmtime)
for img_file in reversed(img_files):
img = imread(img_file)
img = imresize(img, (img_size, img_size))
mask_file = re.sub('img2.jpg$', 'msk1.png', img_file)
mask = imread(mask_file)
mask = imresize(mask, (img_size, img_size), interp='nearest')
mask1 = mask[:, :, 0]
batched1 = img.reshape(1, img_size, img_size, 3).astype(float)
pred1 = model.predict(standardize(batched1)).reshape(
img_size, img_size)
mask1 = mask1.astype(float) / 255
dice = np_dice_coef(mask1, pred1)
print('dice1: ', dice)
print('sum ', np.sum(mask1))
print('shap ', mask1.shape)
pred1 = beautify(pred1)
if True:
plt.subplot(2, 2, 1)
plt.imshow(img)
#plt.subplot(2, 2, 2)
#plt.imshow(mask)
plt.subplot(2, 2, 3)
plt.imshow(pred1)
plt.subplot(2, 2, 4)
plt.imshow(mask1)
plt.show()
def main(img_file):
with CustomObjectScope(custom_objects()):
model1 = load_model(SAVED_MODEL1)
img = imread(img_file)
img = imresize(img, (img_size, img_size))
mask_file = re.sub('img2.jpg$', 'msk1.png', img_file)
mask = imread(mask_file)
mask = imresize(mask, (img_size, img_size))
batched1 = img.reshape(1, img_size, img_size, 3).astype(float)
pred1 = model1.predict(standardize(batched1)).reshape(img_size, img_size)
if True:
plt.subplot(2, 2, 1)
plt.imshow(img)
plt.subplot(2, 2, 2)
plt.imshow(pred1)
plt.subplot(2, 2, 3)
plt.imshow(mask)
plt.show()
def main(weight_file):
model = MobileUNet(input_shape=(128, 128, 3), alpha=1, alpha_up=0.25)
model.summary()
model.load_weights(weight_file, by_name=True)
images = np.load('data/id_pack/images-128.npy')
masks = np.load('data/id_pack/masks-128.npy')
# only hair
masks = masks[:, :, :, 0].reshape(-1, size, size)
_, images, _, masks = train_test_split(images,
masks,
test_size=0.2,
random_state=seed)
for img, mask in zip(images, masks):
batched1 = img.reshape(1, size, size, 3).astype(float)
batched2 = img.reshape(1, size, size, 3).astype(float)
t1 = time.time()
pred1 = model.predict(standardize(batched1)).reshape(size, size)
elapsed = time.time() - t1
print('elapsed1: ', elapsed)
dice = np_dice_coef(mask.astype(float) / 255, pred1)
print('dice1: ', dice)
if True:
plt.subplot(2, 2, 1)
plt.imshow(img)
plt.subplot(2, 2, 2)
plt.imshow(mask)
plt.subplot(2, 2, 3)
plt.imshow(pred1)
plt.show()
x, y = utils_load_dataset.load_mimic_patient(
patient_id=int(args.dataset_option),
csv_filename=os.path.join(dir_data, 'hr.csv'))
x, y, x_test, y_test = util.format_data_torch(
*data.train_val_split(x, y, frac_train=0.75, seed=args.seed))
else:
print('dataset not found')
if args.validation_mode:
# split training set into smaller training set and validation set, use as training set and test set going forward
x, y, x_test, y_test = data.train_val_split(x,
y,
frac_train=0.8,
seed=args.seed + 50)
x, y, x_test, y_test = data.standardize(x, y, x_test, y_test)
# center around zero
x = x - 0.5
x_test = x_test - 0.5
## check prior
x_plot = torch.linspace(-0.5, 0.5, 100).reshape(-1, 1)
y_samp_prior = net.sample_functions_prior(x_plot, n_samp=1000)
fig, ax = util.plot_functions(x_plot,
y_samp_prior,
x=x,
y=y,
x_test=x_test,
y_test=y_test)
def main(pb_file, img_file):
"""
Predict and visualize by TensorFlow.
:param pb_file:
:param img_file:
:return:
"""
with tf.gfile.GFile(pb_file, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
with tf.Graph().as_default() as graph:
tf.import_graph_def(graph_def, name=prefix)
for op in graph.get_operations():
print(op.name)
x = graph.get_tensor_by_name('%s/input_1:0' % prefix)
y = graph.get_tensor_by_name('%s/output_0:0' % prefix)
loaded_image = cv2.cvtColor(cv2.imread(img_file, -1), cv2.COLOR_BGR2RGB)
resized_image = cv2.resize(loaded_image, (128, 128))
input_image = np.expand_dims(np.float32(resized_image[:128, :128]),
axis=0) / 255.0
# images = np.load(img_file).astype(float)
# img_h = images.shape[1]
# img_w = images.shape[2]
with tf.Session(graph=graph) as sess:
# for img in images:
# batched = img.reshape(-1, img_h, img_w, 3)
normalized = standardize(input_image)
converter = tf.contrib.lite.TFLiteConverter.from_session(
sess, [x], [y])
tflite_model = converter.convert()
open("artifacts/converted_model.tflite", "wb").write(tflite_model)
# Load TFLite model and allocate tensors.
interpreter = tf.contrib.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Test model on random input data.
# input_shape = input_details[0]['shape']
input_data = np.array(normalized, dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
# print(output_data)
# pred = sess.run(y, feed_dict={
# x: normalized
# })
plt.imshow(output_data.reshape(128, 128))
plt.show()
# initialize the video stream and allow the cammera sensor to warmup
print("[INFO] camera sensor warming up...")
vs = VideoStream().start()
time.sleep(2.0)
with CustomObjectScope(custom_objects()):
model1 = load_model(SAVED_MODEL1)
# loop over the frames from the video stream
while True:
frame = vs.read()
resized = imutils.resize(frame, height=size)
crop_frame = resized[y:y + height, x:x + width]
reshaped = crop_frame.reshape(1, size, size, 3).astype(float)
pred1 = model1.predict(standardize(reshaped)).reshape(size, size)
# show the frame
cv2.imshow("Frame", crop_frame)
cv2.imshow("Segment", pred1)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
cv2.destroyAllWindows()
vs.stop()
def main(experiments, train_set, epochs, batch_size, l2, units, dropout,
patience):
# Set PRNG seeds so that all runs have the same initial conditions
helpers.seed()
# Standardize and split data
x, y = data.load(train_set)
x = data.standardize(x, np.mean(x, axis=(0, 1, 2)),
np.std(x, axis=(0, 1, 2)))
x_train, x_validation, y_train, y_validation = sklearn.model_selection.train_test_split(
x, y, test_size=0.15, shuffle=True, stratify=y)
del x
del y
# Settings
run = os.path.join(
experiments,
f'lambda{l2}_units{units}_dropout{dropout}_patience{patience}')
helpers.create_or_recreate_dir(run)
model_filename = os.path.join(run, 'model.h5')
csv_filename = os.path.join(run, 'train.csv')
callbacks = [
helpers.TrainingTimeLogger(),
tf.keras.callbacks.ReduceLROnPlateau(monitor='val_acc',
factor=0.1,
patience=10,
verbose=1,
mode='max',
min_delta=EPSILON,
cooldown=0,
min_lr=0),
tf.keras.callbacks.EarlyStopping(monitor='val_acc',
min_delta=EPSILON,
patience=patience,
verbose=1,
mode='max',
baseline=None),
tf.keras.callbacks.CSVLogger(filename=csv_filename,
separator=',',
append=False),
]
# Train
model = custom2(l2, units, dropout)
model.compile(loss='binary_crossentropy',
optimizer=tf.keras.optimizers.SGD(lr=10e-4,
momentum=0.9,
decay=0.0,
nesterov=False),
metrics=['accuracy'])
model.fit(x=x_train,
y=y_train,
validation_data=(x_validation, y_validation),
batch_size=batch_size,
epochs=epochs,
verbose=1,
callbacks=callbacks,
shuffle=True)
model.save(model_filename)
del model
# -*- coding: utf-8 -*-
import numpy as np
import tests
import data
import matplotlib
# %matplotlib auto #view plot in separated window #tap into the console
matplotlib.rcParams.update({'font.size': 30})
folder = 'datasets'
file_names = ['iris', 'wine', 'glass', 'pima', 'seeds']
metrics = ['euclidean', 'manhattan']
weights = ['uniform', 'distance']
scoring = ['accuracy', 'f1_macro']
# Prepare data
X, y = data.read_data(folder, file_names[4])
X = data.standardize(X)
# Run tests
k_test_set = np.arange(1, 21)
weight = 'uniform'
#tests.test_metrics_and_k(X, y, scoring, k_test_set, metrics, weight, True, 5)
#tests.test_weights_and_k(X, y, scoring, k_test_set, weights, 'manhattan', True, 5)
n_test_set = np.arange(2, 15)
tests.test_ncrossvalidation_with_const_k(X, y, n_test_set, scoring, 9,
'manhattan', 'uniform')
#tests.test_ncrossvalidation_with_const_n(X, y, k_test_set, scoring, n, metric, weight)
def run_gp(dataset, dataset_option, seed, x_plot, sig2, dir_data, dir_out):
## dataset
if dataset == 'motorcycle':
x, y, x_test, y_test = reshape_dataset(
*data.load_motorcycle(dir_data, seed=seed))
elif dataset == 'finance':
x, y, x_test, y_test = reshape_dataset(
*data.load_finance2(dir_data, seed=seed))
elif dataset == 'mimic_gap':
x, y, x_test, y_test = reshape_dataset(
*utils_load_dataset.load_mimic_patient_gap(
dir_data, subject_id=dataset_option))
elif dataset == 'GPdata':
x, y, x_val, y_val, x_test, y_test, _, _ = data.load_GPdata(
dir_data, lengthscale=dataset_option)
x, y, x_test, y_test = reshape_dataset(x, y, x_test, y_test)
elif dataset == 'finance_nogap':
x, y, x_test, y_test = reshape_dataset(
*data.load_finance2(dir_data, gaps=None, seed=seed))
elif dataset == 'mimic':
x, y = utils_load_dataset.load_mimic_patient(
patient_id=int(dataset_option),
csv_filename=os.path.join(dir_data, 'hr.csv'))
x, y, x_test, y_test = reshape_dataset(
*data.train_val_split(x, y, frac_train=0.75, seed=seed))
x, y, x_test, y_test = data.standardize(x, y, x_test, y_test)
## fit gp
kernel = GPy.kern.RBF(input_dim=1, variance=1.0, lengthscale=1.0)
m = GPy.models.GPRegression(x, y, kernel)
m.Gaussian_noise.variance.fix()
m.Gaussian_noise.variance = sig2
m.kern.lengthscale.constrain_bounded(1 / (5 * 2 * np.pi), 10)
m.optimize_restarts(num_restarts=10, verbose=False)
# ploterior metrics
y_plot_samp = m.posterior_samples_f(x_plot, size=1000)
y_plot_samp = np.moveaxis(y_plot_samp, [0, 1, 2], [1, 2, 0])
y_plot_pred, y_plot_pred_var = m.predict(x_plot,
full_cov=False,
include_likelihood=False)
y_test_pred, y_test_pred_var = m.predict(x_test,
full_cov=False,
include_likelihood=False)
y_test_samp = m.posterior_samples_f(x_test, size=1000)
y_test_samp = np.moveaxis(y_test_samp, [0, 1, 2], [1, 2, 0])
ll_test = np.mean(m.log_predictive_density(x_test, y_test))
rmse_test = np.sqrt(np.mean((y_test_pred - y_test)**2))
# save
samples = {
'x_plot': x_plot,
'y_plot_pred': np.squeeze(y_plot_pred),
'y_plot_pred_var': y_test_pred_var,
'y_plot_samp': y_plot_samp,
'y_test_pred': np.squeeze(y_test_pred),
'y_test_pred_var': y_test_pred_var,
'y_test_samp': y_test_samp,
'x': x,
'y': y,
'x_test': x_test,
'y_test': y_test,
'sig2': m.Gaussian_noise.variance.item(),
'll_test': ll_test,
'rmse_test': rmse_test,
'kernel_lengthscale': m.kern.lengthscale.item(),
'kernel_variance': m.kern.variance.item()
}
if not os.path.exists(dir_out):
os.makedirs(dir_out)
np.save(os.path.join(dir_out, 'samples.npy'), samples)