class process_network:
def __init__(self):
ap = argparse.ArgumentParser()
ap.add_argument("-m",
"--model",
required=True,
help="path to trained model mode")
ap.add_argument("-i",
"--image",
required=True,
help="path to input image")
self.args = vars(ap.parse_args())
print("[*] Loading network ..")
self.model = load_model(self.args["model"])
print("[*] Done")
self.path_frame = self.args["image"]
#self.create_session()
self.frame = cv2.imread(self.path_frame)
self.load_img(self.frame)
self.getProba()
#self.close_session()
def create_session(self):
print("[*] Settings config ..")
config = ConfigProto()
config.gpu_options.allow_growth = True
self.session = InteractiveSession(config=config)
print("[*] Done")
def close_session(self):
print("[!] Closing session ..")
self.session.close()
del session
print("[*] Done")
def load_img(self, frame):
#image = cv2.imread(args["image"])
self.image = frame
self.orig = self.image.copy()
self.image = cv2.resize(self.image, IMAGE_SIZE)
self.image = self.image.astype("float") / 255.0
self.image = img_to_array(self.image)
self.image = np.expand_dims(
self.image, axis=0) # to have dims (1, width, height, 3)
def getProba(self):
nothugo, hugo = self.model.predict(self.image)[0]
label = "Hugo" if hugo > nothugo else "Unknown"
proba = hugo if hugo > nothugo else nothugo
print("Hugo {} Not Hugo {}".format(str(hugo), str(nothugo)))
label = "{}: {:.2f}%".format(label, proba * 100)
output = imutils.resize(self.orig, width=400)
cv2.putText(output, label, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 255, 0), 2)
cv2.imshow("Output", output)
cv2.waitKey(0)
def train_and_eval(DIR,
EPOCHS=20,
BS=16,
IMAGE_COUNT=139,
VALIDATION_COUNT=134,
learning_rate=0.05,
beta=0.5,
input_size=(64, 64, 32, 1)):
# session setting
""" os.environ['TF_CPP_MIN_LOG_LEVEL']
0 = all messages are logged (default behavior)
1 = INFO messages are not printed
2 = INFO and WARNING messages are not printed
3 = INFO, WARNING, and ERROR messages are not printed
"""
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
gpu_options = GPUOptions(per_process_gpu_memory_fraction=1.0)
config = ConfigProto(gpu_options=gpu_options)
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
print("Number of GPUs Available: ",
len(tf.config.experimental.list_physical_devices('GPU')))
## program parameter
BASE_DIR = DIR
TRAIN_DIR_PATH = BASE_DIR + 'train/'
VALIDATION_DIR_PATH = BASE_DIR + 'validation/'
seed = 1
time_stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
# create logs
log_dir = "logs/fit/" + time_stamp
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=0)
file_writer = tf.summary.create_file_writer(log_dir)
## training parameter
loss_func = tversky_loss(beta)
steps_per_epoch = 70
input_size = input_size
## construct training and validation set
training_data = PPDataGenerator(TRAIN_DIR_PATH,
batch_size=BS,
image_size=64)
validating_data = PPDataGenerator(VALIDATION_DIR_PATH,
batch_size=BS,
image_size=64)
## load model
model = unet_norm(input_size=input_size,
loss_func=loss_func,
l_rate=learning_rate)
print('#### Model loaded')
## training begin
model.fit_generator(training_data,
steps_per_epoch=steps_per_epoch,
epochs=EPOCHS,
validation_data=validating_data,
callbacks=[tensorboard_callback])
if not os.path.exists('./model/'):
os.makedirs('./model/')
model.save("model/UNet_%s.h5" % time_stamp)
print("model saved at model/UNet_%s.h5" % time_stamp)
text = 'UNet_%s.h5\n\
loss: weighted_dice %s\n\
learninf rate: %s\n\
image size: %s\n'\
%(time_stamp, beta,learning_rate,input_size)
with open("./log.txt", "a") as myfile:
myfile.write(text)
## prediction begin
TP_sum, FP_sum, FN_sum, TP_P_sum, FP_P_sum, FN_P_sum = predict_folder(
model,
'%stest/' % BASE_DIR,
save_mode=4,
save_dir='./result/%s' % (time_stamp))
eval_precision = divide(TP_sum, TP_sum + FP_sum)
eval_recall = divide(TP_sum, TP_sum + FN_sum)
eval_precision_P = divide(TP_P_sum, TP_P_sum + FP_P_sum)
eval_recall_P = divide(TP_P_sum, TP_P_sum + FN_P_sum)
text = 'Evaluation result: %s\n\
TP : %s\n\
FP : %s\n\
FN : %s\n\
Recall by pixel: %s\n\
Precision by pixel: %s\n\
Recall by area: %s\n\
Precision by area: %s\n\n\n'\
%(time_stamp, TP_sum, FP_sum, FN_sum, eval_recall_P, eval_precision_P, eval_recall, eval_precision)
with open("./log.txt", "a") as myfile:
myfile.write(text)
file_writer.close()
InteractiveSession.close(session)
# Compile model
model.compile(loss='categorical_crossentropy',
optimizer=Optim,
metrics=['accuracy'])
model.load_weights(
os.path.dirname(InitialModel) + 'W_' + os.path.basename(InitialModel))
model.summary()
'''Tune and Fit CNN'''
Labels1Hot = to_categorical(Label)
(trainX, testX, trainY, testY) = train_test_split(Tensor,
Labels1Hot,
test_size=0.2)
when2stop = MyThresholdCallback(threshold=targetacc)
history = model.fit(trainX,
trainY,
epochs=120,
batch_size=batches,
validation_data=(testX, testY),
callbacks=when2stop)
Predictions = np.argmax(model.predict(testX), axis=1)
Observations = np.argmax(testY, axis=1)
report = metrics.classification_report(Observations, Predictions, digits=3)
print('Classification report for ' + TuningDataName)
print(report)
model.save(OutPath + TuningDataName + '.h5')
#close the TF session
session.close()
# @Author : honwaii # @Email : [email protected] # @File : leeson06.py from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np import tensorflow.compat.v1 as tf from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession # tf.executing_eagerly() config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) InteractiveSession.close() def basic_operation(): x = [[2.]] m = tf.matmul(x, x) print("x matmul x = {}".format(m)) a = tf.constant([[1, 2], [3, 4]]) print(a) b = tf.add(a, 1) print(b) # element-wise multiplication print(a * b) print(tf.matmul(a, b)) c = np.multiply(a, b) print(c)
reconstructed[i],
cmap=plt.cm.gray)
print('\nreconstruction data saved to : \n', pred_res_path)
# In[]:
# illustrate the results
start = 0
end = len(reconstructed) - 1
idx = np.linspace(start, end,
10).astype('int32') # show 10 results at equal intervals
in_images = in_imgs[idx]
recon_images = reconstructed[idx]
fig, axes = plt.subplots(nrows=2,
ncols=10,
sharex=True,
sharey=True,
figsize=(20, 4))
for images, row in zip([in_images, recon_images], axes):
for img, ax in zip(images, row):
ax.imshow(img.reshape((*pic_size)), cmap='gray')
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
fig.tight_layout(pad=0.1)
plt.show()
# In[24]:
# release
sess.close()
def main(image_dir="./", net_loc="../cnn_mnist_10c.h5"):
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
K.set_session(session)
print(image_dir)
print(net_loc)
# from ptpdb import set_trace
# set_trace()
# imcollection = np.array(imread_collection(image_dir))[:, :, :, 0]
imcollection = np.array(imread_collection(f"{image_dir}/*.png"))
net_generated_data = np.expand_dims(imcollection, 3)
x_real_train, x_real_test = keras_extract_mnist_digits()
num_samples = min(len(net_generated_data), len(x_real_test))
x_real_train = x_real_train / 255
x_real_test = x_real_test / 255
net_generated_data = net_generated_data / 255
np.random.shuffle(x_real_train)
np.random.shuffle(x_real_test)
np.random.shuffle(net_generated_data)
x_real_train = x_real_train[:num_samples]
x_real_test = x_real_test[:num_samples]
full_classifier = keras.models.load_model(net_loc)
req_layer = "flatten_1"
classifier = Model(
inputs=full_classifier.input,
outputs=full_classifier.get_layer(req_layer).output,
)
print("Calculating FCD for train data")
fcd_train = compute_real_fcd(x_real_train, classifier)
print("Calculating FCD for test data")
fcd_test = compute_real_fcd(x_real_test, classifier)
print(
f"samples = {num_samples} train fcd = {fcd_train:.3g} test fcd = {fcd_test:.3g}"
)
net_real_data = x_real_train
assert len(net_generated_data) == len(net_real_data)
print(
np.max(net_generated_data),
np.min(net_generated_data),
f"{np.std(net_generated_data):.3f}",
f"{np.mean(net_generated_data):.3f}",
)
print(
np.max(net_real_data),
np.min(net_real_data),
f"{np.std(net_real_data):.3f}",
f"{np.mean(net_real_data):.3f}",
)
real_act = classifier.predict(net_real_data)
print(real_act.shape)
gen_act = classifier.predict(net_generated_data)
print("Calculating FCD for generated data")
fcd_tensor = diagonal_only_frechet_classifier_distance_from_activations(
tf.convert_to_tensor(real_act), tf.convert_to_tensor(gen_act))
fcd = session.run(fcd_tensor)
print(f"fcd = {fcd:.3g}")
session.close()
sys.exit(0)
fcd_iters = 2
gen_fcd_arr = []
for fcd_i in range(fcd_iters):
# inverse normalization due to tanh
# net_generated_data = (net_generated_data + 1) / 2
net_real_data = x_real_train
assert len(net_generated_data) == len(net_real_data)
print(
np.max(net_generated_data),
np.min(net_generated_data),
f"{np.std(net_generated_data):.3f}",
f"{np.mean(net_generated_data):.3f}",
)
print(
np.max(net_real_data),
np.min(net_real_data),
f"{np.std(net_real_data):.3f}",
f"{np.mean(net_real_data):.3f}",
)
np.random.shuffle(net_generated_data)
np.random.shuffle(net_real_data)
real_act = classifier.predict(net_real_data)
gen_act = classifier.predict(net_generated_data)
print("Calculating FCD for generated data")
fcd_tensor = diagonal_only_frechet_classifier_distance_from_activations(
tf.convert_to_tensor(real_act), tf.convert_to_tensor(gen_act))
sess = K.get_session()
fcd = sess.run(fcd_tensor)
gen_fcd_arr.append(fcd)
class Application:
def __init__(self):
ap = argparse.ArgumentParser()
ap.add_argument("-d",
"--dataset",
required=True,
type=str,
help="path to input dataset")
ap.add_argument("-p",
"--plot",
type=str,
default="plot.png",
help="path to output accuracy/loss plot")
ap.add_argument("-n",
"--number_images",
type=int,
default=5000,
help="number of images to load")
ap.add_argument("-e",
"--epochs",
type=int,
default=25,
help="number of epochs")
ap.add_argument("-b",
"--batch_size",
type=int,
default=16,
help="batch size")
ap.add_argument("-lr",
"--learning_rate",
type=float,
default=1e-3,
help="learning rate")
ap.add_argument(
"-m",
"--model",
type=str,
default="RESNET50",
help=
"model to choose `LENET` or `INCEPTIONV3` or `RESNET50` or `VGG16`"
)
ap.add_argument("-g",
"--gpu",
type=str,
default="yes",
help="Use the gpu `yes` or `no`")
self.args = vars(ap.parse_args())
self.model = Model(self.args)
def run(self):
self.model.run()
self.model.save_plot()
def create_session(self):
print("[*] Settings config ..")
if self.args["gpu"] == "no":
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
if tf.test.gpu_device_name():
print('GPU found')
else:
print("No GPU found")
config = ConfigProto()
self.session = InteractiveSession(config=config)
print("[*] Done")
#config.gpu_options.allow_growth = True
#config.gpu_options.allocator_type = "BFC"
#config.gpu_options.per_process_gpu_memory_fraction = 0.90
def close_session(self):
print("[!] Closing session ..")
self.session.close()
del self.session
print("[*] Done")
def train_and_eval(params):
# session setting
""" os.environ['TF_CPP_MIN_LOG_LEVEL']
0 = all messages are logged (default behavior)
1 = INFO messages are not printed
2 = INFO and WARNING messages are not printed
3 = INFO, WARNING, and ERROR messages are not printed
"""
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
gpu_options = GPUOptions(per_process_gpu_memory_fraction=1.0)
config = ConfigProto(gpu_options=gpu_options)
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
print("Number of GPUs Available: ",
len(tf.config.experimental.list_physical_devices('GPU')))
## program parameter
BASE_DIR = params[0]
TRAIN_DIR_PATH = BASE_DIR + 'train/'
VALIDATION_DIR_PATH = BASE_DIR + 'validation/'
seed = params[1]
time_stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
log_dir = params[2] + time_stamp
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=0)
file_writer = tf.summary.create_file_writer(log_dir)
## training parameter
loss_func = params[3]
input_size = params[4]
steps_per_epoch = params[5]
EPOCHS = params[6]
BS = params[7]
IMAGE_COUNT = params[8]
VALIDATION_COUNT = params[9]
learning_rate = params[10]
## construct training and validation set
training_data = DataGenerator(TRAIN_DIR_PATH,
batch_size=BS,
image_size=input_size[0])
validating_data = DataGenerator(VALIDATION_DIR_PATH,
batch_size=BS,
image_size=input_size[0])
## load model
model = unet(input_size=input_size,
loss_func=loss_func,
l_rate=learning_rate)
model.summary()
print('#### Model loaded')
## training begin
model.fit_generator(training_data,
steps_per_epoch=steps_per_epoch,
epochs=EPOCHS,
validation_data=validating_data,
callbacks=[tensorboard_callback])
if not os.path.exists('./model/'):
os.makedirs('./model/')
model.save("model/UNet_%s.h5" % time_stamp)
print("model saved at model/UNet_%s.h5" % time_stamp)
text = 'UNet_%s.h5\n\
Learning rate: %s\n\
Image size: %s\n\
Epoch: %s\n\
Batch size: %s\n\
Step per epoch: %s\n'\
%(time_stamp, learning_rate, input_size, steps_per_epoch, BS, EPOCHS)
with open("./log.txt", "a") as myfile:
myfile.write(text)
file_writer.close()
InteractiveSession.close(session)
## prediction begin
predict_folder(model,
'%stest/' % BASE_DIR,
save_dir='./result/%s' % (time_stamp))
InteractiveSession.close(session)
