def process_annotation(self, file_annotations, path_out, folder_annotation=None, markup_only=False):
start_time = time.time()
if folder_annotation is None:
foldername = '/'.join(file_annotations.split('/')[:-1]) + '/'
else:
foldername = folder_annotation
filename_markup_out = file_annotations.split('/')[-1].split('.')[0]+'_pred.txt'
filename_markup_copy = path_out+file_annotations.split('/')[-1]
if file_annotations!= filename_markup_copy:
tools_IO.copyfile(file_annotations,filename_markup_copy)
with open(file_annotations) as f:lines = f.readlines()[1:]
local_filenames = [line.split(' ')[0] for line in lines]
local_filenames = sorted(set(local_filenames))
result = [('filename', 'x_left', 'y_top', 'x_right', 'y_bottom', 'class_ID', 'confidence')]
for local_filename in local_filenames:
filename_image_out = path_out + local_filename if not markup_only else None
for each in self.process_file(foldername+local_filename, filename_image_out):
result.append(each)
tools_IO.save_mat(result, path_out + filename_markup_out, delim=' ')
total_time = (time.time() - start_time)
print('%s sec in total - %f per image\n\n' % (total_time, int(total_time) / len(local_filenames)))
return
def generate_sine(self,
filename_output,
max_periods=3,
noise_signal_ratio=0.0):
numpy.random.seed(125)
max_periods = max_periods
X = numpy.random.rand(self.len, self.dim)
Y = numpy.zeros(self.len, dtype=numpy.float32)
A = numpy.random.rand(self.dim + 1)
ph = 2 * numpy.pi * numpy.random.rand(self.dim)
for i in range(0, self.dim):
T = 0.5 + 0.5 * numpy.random.rand(1)[0]
X[:, i] = T * numpy.arange(self.len) / self.len
periods = 1 + max_periods * numpy.random.rand(self.dim)
for i in range(0, self.dim):
Y[:] = A[i] * numpy.sin(ph[i] +
2 * numpy.pi * X[:, i] * periods[i])
Y += A[-1]
noise = self.generate_noise(noise_signal_ratio)
Y += noise
mat = numpy.vstack((Y, X.T)).T
tools_IO.save_mat(mat, filename_output)
return mat
def process_folder(self,
path_input,
path_out,
mask='*.jpg',
limit=1000000,
markup_only=False):
tools_IO.remove_files(path_out)
start_time = time.time()
local_filenames = numpy.array(fnmatch.filter(listdir(path_input),
mask))[:limit]
result = [('filename', 'x_left', 'y_top', 'x_right', 'y_bottom',
'class_ID', 'confidence')]
local_filenames = numpy.sort(local_filenames)
for local_filename in local_filenames:
filename_out = path_out + local_filename if not markup_only else None
for each in self.process_file(path_input + local_filename,
filename_out):
result.append(each)
tools_IO.save_mat(result, path_out + 'markup_res.txt', delim=' ')
total_time = (time.time() - start_time)
print('Processing: %s sec in total - %f per image' %
(total_time, int(total_time) / len(local_filenames)))
return
# ----------------------------------------------------------------------------------------------------------------------
def save_markers(self,filename_out,do_transform = False):
if do_transform:
X = self.my_VBO.marker_positions[1:].copy()
X = numpy.array(X)
X[:,1] = 0-X[:,1]
tools_IO.save_mat(X, filename_out,delim=',')
else:
tools_IO.save_mat(self.my_VBO.marker_positions[1:], filename_out,delim=',')
return
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png,*.jpg'):
if not os.path.exists(path_output): os.makedirs(path_output)
dict_last_layers, dict_bottlenects = self.__last_full_layers4()
outputs = [
self.model.layers[len(self.model.layers) + i].output
for i in dict_bottlenects.values()
]
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = tools_IO.get_filenames(path_input + each,
mask)[:limit]
feature_filename = path_output + '/' + each + '_' + self.name + '.txt'
features, filenames = [], []
if not os.path.isfile(feature_filename):
bar = progressbar.ProgressBar(max_value=len(local_filenames))
for b, local_filename in enumerate(local_filenames):
bar.update(b)
image = cv2.imread(path_input + each + '/' +
local_filename)
if image is None: continue
image_resized = tools_image.smart_resize(
image, self.input_image_size[0],
self.input_image_size[1])
image_resized = numpy.expand_dims(image_resized / 255.0,
axis=0)
bottlenecks = Model(self.model.input,
outputs).predict(image_resized)
feature = numpy.hstack(
(bottlenecks[0].flatten(), bottlenecks[1].flatten()))
features.append(feature[0])
filenames.append(local_filename)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def plot_mAP_overlap(folder_annotation,
file_markup_true,
file_markup_pred,
filename_meta,
folder_out,
out_prefix='',
delim=' '):
input_image_size, class_names, anchors, anchor_mask, obj_threshold, nms_threshold = tools_YOLO.load_metadata(
filename_meta)
colors = tools_YOLO.generate_colors(len(class_names))
ovp_ths = [0.9, 0.8, 0.7, 0.6, 0.5, 0.1]
ovd_ths = [0.1, 0.2, 0.5, 0.99]
results = []
for ovp_th in ovp_ths:
out_dir = folder_out + 'ovp_%02d/' % int(ovp_th * 100)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
for ovd_th in ovd_ths:
precisions, recalls, confidences, class_IDs = get_precsion_recall_data_from_markups(
folder_annotation,
file_markup_true,
file_markup_pred,
None,
ovp_th,
ovd_th,
delim=delim)
mAP = 0
for i, class_ID in enumerate(class_IDs):
if len(precisions[i]) > 1:
xxx = numpy.array(
[precisions[i], recalls[i], confidences[i]]).T
filename_out = out_dir + out_prefix + 'OVD_%02d_AP_%02d_%s.txt' % (
int(ovd_th * 100), class_ID, class_names[class_ID])
tools_IO.save_mat(xxx, filename_out)
filename_out = out_dir + out_prefix + 'OVD_%02d_AP_%02d_%s.png' % (
int(ovd_th * 100), class_ID, class_names[class_ID])
AP = write_precision_recall(
filename_out,
precisions[i],
recalls[i],
caption='ovp %1.2f ovd %1.2f ' % (ovp_th, ovd_th) +
class_names[class_ID],
color=(colors[class_ID][2] / 255.0,
colors[class_ID][1] / 255.0,
colors[class_ID][0] / 255.0))
mAP += AP
results.append(mAP / len(class_IDs))
return results[0]
def save_stats(self, hist):
c1 = numpy.array(['accuracy'] + hist.history['acc'])
c2 = numpy.array(['val_acc'] + hist.history['val_acc'])
c3 = numpy.array(['loss'] + hist.history['loss'])
c4 = numpy.array(['val_loss'] + hist.history['val_loss'])
mat = (numpy.array([c1, c2, c3, c4]).T)
tools_IO.save_mat(mat,
self.folder_debug + self.name + '_learn_rates.txt')
return
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png,*.jpg'):
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
if not os.path.exists(path_output):
os.makedirs(path_output)
#else:
#tools_IO.remove_files(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = tools_IO.get_filenames(path_input + each,
mask)[:limit]
feature_filename = path_output + '/' + each + '_' + self.name + '.txt'
features, filenames = [], []
if not os.path.isfile(feature_filename):
bar = progressbar.ProgressBar(max_value=len(local_filenames))
for b, local_filename in enumerate(local_filenames):
bar.update(b)
image = cv2.imread(path_input + each + '/' +
local_filename)
if image is None: continue
image = cv2.resize(
image, (self.input_shape[0], self.input_shape[1]))
feature = sess.run(self.fc7, feed_dict={self.x: [image]})
features.append(feature[0])
filenames.append(local_filename)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
sess.close()
return
def generate_features(self,
path_input,
path_output,
mask='*.png',
limit=1000000):
if not os.path.exists(path_output):
os.makedirs(path_output)
else:
tools_IO.remove_files(path_output)
tools_IO.remove_folders(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = tools_IO.get_filenames(path_input + each,
mask)[:limit]
feature_filename = path_output + '/' + each + '_' + self.name + '.txt'
features, filenames = [], []
if not os.path.isfile(feature_filename):
bar = progressbar.ProgressBar(max_value=len(local_filenames))
for b, local_filename in enumerate(local_filenames):
bar.update(b)
img = cv2.imread(path_input + each + '/' + local_filename)
if img is None: continue
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img,
self.input_shape).astype(numpy.float32)
model = Model(inputs=self.model.input,
outputs=self.model.get_layer(
'global_average_pooling2d_1').output)
feature = model.predict(
preprocess_input(numpy.array([img])))[0]
features.append(feature)
filenames.append(local_filename)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def process_annotation(self,
file_annotations,
filename_markup_out_true,
filename_markup_out_pred,
folder_annotation=None,
markup_only=False,
delim=' ',
limit=1000000):
start_time = time.time()
if folder_annotation is None:
foldername = '/'.join(file_annotations.split('/')[:-1]) + '/'
else:
foldername = folder_annotation
result = [('filename', 'x_left', 'y_top', 'x_right', 'y_bottom',
'class_ID', 'confidence')]
fact = [('filename', 'x_left', 'y_top', 'x_right', 'y_bottom',
'class_ID', 'confidence')]
with open(file_annotations) as f:
lines = f.readlines()
lines = lines[1:]
if limit > 0:
lines = lines[:limit]
else:
limit *= -1
lines = lines[-limit:]
list_filenames = sorted(
set([foldername + line.split(delim)[0] for line in lines]))
for each in lines:
each = each.split('\n')[0]
fact.append(each.split(delim))
tools_IO.save_mat(fact, filename_markup_out_true, delim=delim)
print('Processing annotation\n')
bar = progressbar.ProgressBar(max_value=len(list_filenames))
for b, local_filename in enumerate(list_filenames):
bar.update(b)
for each in self.process_file(local_filename, None):
each[0] = local_filename.split(foldername)[1]
result.append(each)
tools_IO.save_mat(result, filename_markup_out_pred, delim=delim)
total_time = (time.time() - start_time)
print('Processing: %s sec in total - %f per image' %
(total_time, int(total_time) / len(list_filenames)))
return
def generate_features(self,
path_input,
path_output,
mask='*.png',
limit=1000000):
if not os.path.exists(path_output):
os.makedirs(path_output)
else:
tools_IO.remove_files(path_output)
tools_IO.remove_folders(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for each in patterns:
print(each)
local_filenames = numpy.array(
fnmatch.filter(listdir(path_input + each), mask))[:limit]
feature_filename = path_output + each + '.txt'
features, filenames = [], []
if not os.path.isfile(feature_filename):
bar = progressbar.ProgressBar(max_value=len(local_filenames))
for b, local_filename in enumerate(local_filenames):
bar.update(b)
image_data = gfile.FastGFile(
path_input + each + '/' + local_filename, 'rb').read()
if image_data is None: continue
feature = sess.run(self.tensor_bottleneck,
{self.tensor_jpeg_data: image_data})[0]
features.append(feature)
filenames.append(local_filename)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png,*.jpg'):
if not os.path.exists(path_output):
os.makedirs(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = tools_IO.get_filenames(path_input + each,
mask)[:limit]
feature_filename = path_output + '/' + each + '_' + self.name + '.txt'
features, filenames = [], []
if not os.path.isfile(feature_filename):
bar = progressbar.ProgressBar(max_value=len(local_filenames))
for b, local_filename in enumerate(local_filenames):
bar.update(b)
image = cv2.imread(path_input + each + '/' +
local_filename)
if image is None: continue
pre_whitened = preprocess(cv2.resize(image, (160, 160)))
feature = self.__inference([pre_whitened], self.sess)
features.append(feature[0])
filenames.append(local_filename)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
# ---------------------------------------------------------------------------------------------------------------------
def generate_features(self,
path_input,
path_output,
mask='*.png',
limit=1000000):
if not os.path.exists(path_output):
os.makedirs(path_output)
else:
tools_IO.remove_files(path_output)
tools_IO.remove_folders(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = numpy.array(
fnmatch.filter(listdir(path_input + each), mask))[:limit]
feature_filename = path_output + each + '.txt'
features = []
if not os.path.isfile(feature_filename):
for i in range(0, local_filenames.shape[0]):
img = cv2.imread(path_input + each + '/' +
local_filenames[i])
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img,
self.input_shape).astype(numpy.float32)
model = Model(inputs=self.model.input,
outputs=self.model.get_layer(
'global_average_pooling2d_1').output)
feature = model.predict(
preprocess_input(numpy.array([img])))[0]
features.append(feature)
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = local_filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png'):
feature_layer = -2
if not os.path.exists(path_output):
os.makedirs(path_output)
else:
tools_IO.remove_files(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = numpy.array(
fnmatch.filter(listdir(path_input + each), mask))[:limit]
feature_filename = path_output + each + '.txt'
features = []
if not os.path.isfile(feature_filename):
for i in range(0, local_filenames.shape[0]):
image = cv2.imread(path_input + each + '/' +
local_filenames[i])
image = cv2.resize(
image,
(self.model.input_shape[1], self.model.input_shape[2]))
feature = Model(inputs=self.model.input,
outputs=self.model.layers[feature_layer].
output).predict(numpy.array([image]))
features.append(feature[0])
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = local_filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png'):
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
if not os.path.exists(path_output):
os.makedirs(path_output)
#else:
#tools_IO.remove_files(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = numpy.array(
fnmatch.filter(listdir(path_input + each), mask))[:limit]
feature_filename = path_output + '/' + each + '.txt'
features = []
if not os.path.isfile(feature_filename):
for i in range(0, local_filenames.shape[0]):
image = cv2.imread(path_input + each + '/' +
local_filenames[i])
image = cv2.resize(
image, (self.input_shape[0], self.input_shape[1]))
feature = sess.run(self.fc7, feed_dict={self.x: [image]})
features.append(feature[0])
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = local_filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
sess.close()
return
def generate_linear(self, filename_output, noise_signal_ratio=0.0):
X = numpy.random.rand(self.len, self.dim)
Y = numpy.zeros(self.len, dtype=numpy.float32)
A = numpy.random.rand(self.dim + 1)
for i in range(0, self.dim):
Y[:] = X[:, i] * A[i]
Y += A[-1]
noise = self.generate_noise(noise_signal_ratio)
Y += noise
mat = numpy.vstack((Y, X.T)).T
tools_IO.save_mat(mat, filename_output)
return mat
def generate_features(self,
path_input,
path_output,
limit=1000000,
mask='*.png'):
if not os.path.exists(path_output):
os.makedirs(path_output)
patterns = numpy.sort(
numpy.array([
f.path[len(path_input):] for f in os.scandir(path_input)
if f.is_dir()
]))
for each in patterns:
print(each)
local_filenames = numpy.array(
fnmatch.filter(listdir(path_input + each), mask))[:limit]
feature_filename = path_output + each + '.txt'
features = []
if not os.path.isfile(feature_filename):
for i in range(0, local_filenames.shape[0]):
image = cv2.imread(path_input + each + '/' +
local_filenames[i])
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(
image, (self.input_shape[0], self.input_shape[1]))
image = image.transpose((2, 0, 1))
image = numpy.expand_dims(image, axis=0)
feature = Model(inputs=self.model.input,
outputs=self.model.get_layer(
'dropout_2').output).predict(image)
features.append(feature[0])
features = numpy.array(features)
mat = numpy.zeros((features.shape[0],
features.shape[1] + 1)).astype(numpy.str)
mat[:, 0] = local_filenames
mat[:, 1:] = features
tools_IO.save_mat(mat, feature_filename, fmt='%s', delim='\t')
return
def extract_boxes_from_labels(folder_out, folder_images, folder_labels_GT):
if not os.path.exists(folder_out): os.mkdir(folder_out)
local_filenames = get_filenames(folder_images, '*.png,*.jpg')
for index, local_filename in enumerate(local_filenames):
base_name = local_filename.split('/')[-1].split('.')[0]
filename_label = folder_labels_GT + base_name + '.txt'
cubes = []
if not os.path.exists(filename_label): continue
with open(filename_label) as f1:
for line_p in f1:
line_p = line_p.strip().split(' ')
cube = get_cube_3D(line_p)
cubes.append(cube.flatten())
tools_IO.save_mat(cubes, folder_out + base_name + '_cube.txt')
return
def align_two_model(filename_obj1, filename_markers1, filename_obj2,
filename_markers2, filename_obj_res, filename_markers_res):
object1 = tools_wavefront.ObjLoader()
object1.load_mesh(filename_obj1, do_autoscale=False)
object2 = tools_wavefront.ObjLoader()
object2.load_mesh(filename_obj2, do_autoscale=False)
markers1 = tools_IO.load_mat(filename_markers1,
dtype=numpy.float,
delim=',')
markers2 = tools_IO.load_mat(filename_markers2,
dtype=numpy.float,
delim=',')
result_markers = markers1.copy()
result_vertex = object1.coord_vert.copy()
for dim in range(0, 3):
min_value_s = markers1[:, dim].min()
min_value_t = markers2[:, dim].min()
max_value_s = markers1[:, dim].max()
max_value_t = markers2[:, dim].max()
scale = (max_value_t - min_value_t) / (max_value_s - min_value_s)
result_markers[:, dim] = (result_markers[:, dim] -
min_value_s) * scale + min_value_t
result_vertex[:, dim] = (result_vertex[:, dim] -
min_value_s) * scale + min_value_t
tools_IO.save_mat(result_markers, filename_markers_res, delim=',')
object1.export_mesh(filename_obj_res,
X=result_vertex,
idx_vertex=object1.idx_vertex)
return
def E2E_fit(self,
filename_input,
path_output,
target_column=0,
use_cashed_model=False,
verbose=False):
dataset = self.load_and_normalize(filename_input)
suffix = ''
if target_column >= 0: suffix = ('%03d_' % target_column)
filename_fact = path_output + 'fact' + suffix + '.txt'
filename_pred = path_output + 'fit_' + suffix + self.classifier.name + '.txt'
if target_column >= 0:
X = numpy.delete(dataset, target_column, axis=1)
Y = dataset[:, target_column]
Y_predict = self.classifier.train(X, Y)
tools_IO.save_mat(self.denormalize(Y.T), filename_fact)
tools_IO.save_mat(self.denormalize(Y_predict.T), filename_pred)
else:
Y_predict = []
for col in range(0, dataset.shape[1]):
Y_predict.append(
self.classifier.train(numpy.delete(dataset, col, axis=1),
dataset[:, col]))
Y_predict = numpy.array(Y_predict).T
tools_IO.save_mat(self.denormalize(dataset), filename_fact)
tools_IO.save_mat(self.denormalize(Y_predict), filename_pred)
if verbose == True:
tools_IO.plot_two_series(filename_fact,
filename_pred,
caption='Fit')
plt.show()
return
def visualize_layers(self, filename_input, path_output):
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
image = cv2.resize(cv2.imread(filename_input),
(self.input_shape[0], self.input_shape[1]))
output = sess.run(self.conv1, feed_dict={self.x:
[image]})[0] #(57,57,96)
cv2.imwrite(
path_output + 'layer01_conv1.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.maxpool1, feed_dict={self.x:
[image]})[0] #(28,28,96)
cv2.imwrite(
path_output + 'layer02_pool1.png',
tools_CNN_view.tensor_gray_3D_to_image(2 * output,
do_colorize=True))
output = sess.run(self.conv2, feed_dict={self.x:
[image]})[0] #(28,28,256)
cv2.imwrite(
path_output + 'layer03_conv2.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.maxpool2, feed_dict={self.x:
[image]})[0] #(13,13,256)
cv2.imwrite(
path_output + 'layer04_pool2.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.conv3, feed_dict={self.x:
[image]})[0] #(13,13,384)
cv2.imwrite(
path_output + 'layer04_conv3.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.conv4, feed_dict={self.x:
[image]})[0] #(13,13,384)
cv2.imwrite(
path_output + 'layer05_conv4.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.conv5, feed_dict={self.x:
[image]})[0] #(13,13,256)
cv2.imwrite(
path_output + 'layer06_conv5.png',
tools_CNN_view.tensor_gray_3D_to_image(output, do_colorize=True))
output = sess.run(self.maxpool5, feed_dict={self.x:
[image]})[0] #(6,6,256)
cv2.imwrite(
path_output + 'layer07_pool5.png',
tools_CNN_view.tensor_gray_3D_to_image(2 * output,
do_colorize=True))
output = sess.run(self.fc6, feed_dict={self.x: [image]})[0] #4096
cv2.imwrite(
path_output + 'layer08_fc6.png',
tools_image.hitmap2d_to_viridis(
tools_CNN_view.tensor_gray_1D_to_image(output)))
output = sess.run(self.fc7, feed_dict={self.x: [image]})[0] #4096
output *= 255.0 / output.max()
cv2.imwrite(
path_output + 'layer09_features.png',
tools_image.hitmap2d_to_viridis(
tools_CNN_view.tensor_gray_1D_to_image(output)))
output = 100 * sess.run(self.layer_feature,
feed_dict={self.x: [image]})[0] #4096
cv2.imwrite(
path_output + 'layer10.png',
tools_image.hitmap2d_to_viridis(
tools_CNN_view.tensor_gray_1D_to_image(output)))
output = 100 * sess.run(self.layer_classes,
feed_dict={self.x: [image]})[0] #1000
cv2.imwrite(
path_output + 'layer11_classes.png',
tools_image.hitmap2d_to_viridis(
tools_CNN_view.tensor_gray_1D_to_image(output)))
idx = numpy.argsort(-output)
mat = numpy.array([output[idx], numpy.array(self.class_names)[idx]]).T
tools_IO.save_mat(mat,
path_output + 'predictions.txt',
fmt='%s',
delim='\t')
sess.close()
return
def E2E(model_in,
metadata_in,
folder_annotation,
file_annotations,
full_folder_out,
limit=10):
file_annotations_train = full_folder_out + 'markup_train_true.txt'
file_annotations_test = full_folder_out + 'markup_test_true.txt'
tools_IO.split_annotation_file(folder_annotation,
file_annotations,
file_annotations_train,
file_annotations_test,
ratio=0.3,
limit=limit)
D = detector_YOLO3.detector_YOLO3(model_in,
metadata_in,
obj_threshold=0.01)
file_markup_train_true = full_folder_out + 'markup_train_true.txt'
file_markup_train_pred = full_folder_out + 'markup_train_pred.txt'
file_markup_test_true = full_folder_out + 'markup_test_true.txt'
file_markup_test_pred = full_folder_out + 'markup_test_pred.txt'
D.learn(file_annotations_train,
full_folder_out,
folder_annotation,
limit=limit)
D.process_annotation(file_annotations_train,
file_markup_train_true,
file_markup_train_pred,
folder_annotation=folder_annotation,
markup_only=True,
limit=limit)
D.process_annotation(file_annotations_test,
file_markup_test_true,
file_markup_test_pred,
folder_annotation=folder_annotation,
markup_only=True,
limit=limit)
tools_mAP.plot_mAP_overlap(folder_annotation,
file_markup_train_true,
file_markup_train_pred,
metadata_in,
full_folder_out,
out_prefix='train_')
tools_mAP.plot_mAP_overlap(folder_annotation,
file_markup_test_true,
file_markup_test_pred,
metadata_in,
full_folder_out,
out_prefix='test_')
mAP_train = tools_mAP.plot_mAP_iou(folder_annotation,
file_markup_train_true,
file_markup_train_pred,
metadata_in,
full_folder_out,
out_prefix='train_')
mAP_test = tools_mAP.plot_mAP_iou(folder_annotation,
file_markup_test_true,
file_markup_test_pred,
metadata_in,
full_folder_out,
out_prefix='test_')
log = [[
'data_source', 'num_last_layers', 'time_train', 'mAP_train', 'mAP_test'
],
[
D.logs.data_source, D.logs.last_layers, D.logs.time_train,
mAP_train, mAP_test
]]
tools_IO.save_mat(log, full_folder_out + 'log.txt')
return
def stage_train_stats(self,
path_output,
labels_fact,
labels_train_pred,
labels_test_pred,
labels_train_prob,
labels_test_prob,
patterns,
X=None,
Y=None,
verbose=False):
labels_pred = numpy.hstack((labels_train_pred, labels_test_pred))
labels_prob = numpy.hstack((labels_train_prob, labels_test_prob))
predictions = numpy.array(
[patterns[labels_fact], patterns[labels_pred], labels_prob]).T
tools_IO.save_mat(
predictions,
path_output + self.classifier.name + '_predictions.txt')
tools_IO.print_accuracy(labels_fact, labels_pred, patterns)
tools_IO.print_accuracy(labels_fact,
labels_pred,
patterns,
filename=path_output + self.classifier.name +
'_confusion_mat.txt')
tools_IO.print_top_fails(labels_fact,
labels_pred,
patterns,
filename=path_output + self.classifier.name +
'_errors.txt')
tools_IO.print_reject_rate(labels_fact,
labels_pred,
labels_prob,
filename=path_output +
self.classifier.name + '_accuracy.txt')
if verbose == True:
#verbose_PCA = True if (X is not None) and (Y is not None) else False
verbose_PCA = False
if verbose_PCA:
print('Extracting features for PCA')
features = self.classifier.images_to_features(X)
fig = plt.figure(figsize=(12, 6))
fig.subplots_adjust(hspace=0.01)
if verbose_PCA:
tools_IO.plot_features_PCA(plt.subplot(1, 3, 1), features, Y,
patterns)
tools_IO.plot_learning_rates1(plt.subplot(1, 3, 2),
fig,
filename_mat=path_output +
self.classifier.name +
'_learn_rates.txt')
tools_IO.plot_confusion_mat(plt.subplot(1, 3, 3),
fig,
filename_mat=path_output +
self.classifier.name +
'_predictions.txt',
caption=self.classifier.name)
else:
tools_IO.plot_learning_rates1(plt.subplot(1, 2, 1),
fig,
filename_mat=path_output +
self.classifier.name +
'_learn_rates.txt')
tools_IO.plot_confusion_mat(plt.subplot(1, 2, 2),
fig,
filename_mat=path_output +
self.classifier.name +
'_predictions.txt',
caption=self.classifier.name)
plt.tight_layout()
plt.show()
return
def draw_annotation_boxes(file_annotations,
file_classes,
file_metadata,
path_out,
delim=' '):
tools_IO.remove_files(path_out, create=True)
input_image_size, class_names, anchors, anchor_mask, obj_threshold, nms_threshold = load_metadata(
file_metadata)
mat = tools_IO.load_mat(file_classes, numpy.str)
if len(mat) <= len(class_names):
class_names[:len(mat)] = mat
foldername = '/'.join(file_annotations.split('/')[:-1]) + '/'
with open(file_annotations) as f:
lines = f.readlines()[1:]
boxes_xyxy = numpy.array([line.split(delim)[1:5] for line in lines],
dtype=numpy.int)
filenames = numpy.array([line.split(delim)[0] for line in lines])
class_IDs = numpy.array([line.split(delim)[5] for line in lines],
dtype=numpy.int)
colors = generate_colors(numpy.max(class_IDs) + 1)
true_boxes = get_true_boxes(foldername,
file_annotations, (416, 416),
delim=' ')
if len(true_boxes) > 6:
anchors = annotation_boxes_to_ancors(true_boxes, 6)
descript_ion = []
for filename in set(filenames):
image = cv2.imread(foldername + filename)
image = tools_image.desaturate(image, 0.9)
idx = numpy.where(filenames == filename)
boxes_resized = []
for box in boxes_xyxy[idx]:
x_min, y_min = tools_image.smart_resize_point(
box[0], box[1], image.shape[1], image.shape[0], 416, 416)
x_max, y_max = tools_image.smart_resize_point(
box[2], box[3], image.shape[1], image.shape[0], 416, 416)
boxes_resized.append([x_min, y_min, x_max, y_max, 0])
statuses = are_boxes_preprocessed_well(boxes_resized, anchors,
anchor_mask, len(class_names))
descript_ion.append([filename, 1 * (statuses.sum() == len(statuses))])
for box, class_ID, status in zip(boxes_xyxy[idx], class_IDs[idx],
statuses):
w = 2 if status > 0 else -1
cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]),
colors[class_ID],
thickness=w)
cv2.putText(image, '{0:d} {1:s}'.format(class_ID,
class_names[class_ID]),
(box[0], box[1] - 4), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
colors[class_ID], 1, cv2.LINE_AA)
cv2.imwrite(path_out + filename, image)
tools_IO.save_mat(descript_ion, path_out + 'descript.ion', delim=' ')
return
def E2E_train_test(self,
filename_input,
path_output,
target_column=0,
use_cashed_model=False,
verbose=False,
ratio=0.5):
dataset = self.load_and_normalize(filename_input)
train_size = int(dataset.shape[0] * ratio)
suffix = ''
if target_column >= 0: suffix = ('%03d_' % target_column)
filename_train_fact = path_output + 'train_fact' + suffix + '.txt'
filename_test_fact = path_output + 'test_fact' + suffix + '.txt'
filename_train_pred = path_output + 'train_pred_' + suffix + self.classifier.name + '.txt'
filename_test_pred = path_output + 'test_pred_' + suffix + self.classifier.name + '.txt'
if target_column >= 0:
X = numpy.delete(dataset, target_column, axis=1)
Y = dataset[:, target_column]
Y_train_predict, Y_test_predict = self.do_train_test(
X, Y, train_size)
tools_IO.save_mat(self.denormalize(Y[:train_size].T),
filename_train_fact)
tools_IO.save_mat(self.denormalize(Y[train_size:].T),
filename_test_fact)
tools_IO.save_mat(self.denormalize(Y_train_predict.T),
filename_train_pred)
tools_IO.save_mat(self.denormalize(Y_test_predict.T),
filename_test_pred)
else:
Y_train_predicts, Y_test_predicts = [], []
for target_column in range(0, dataset.shape[1]):
Y_train_predict, Y_test_predict = self.do_train_test(
numpy.delete(dataset, target_column, axis=1),
dataset[:, target_column], train_size)
Y_train_predicts.append(Y_train_predict)
Y_test_predicts.append(Y_test_predict)
tools_IO.save_mat(self.denormalize(dataset[:train_size]),
filename_train_fact)
tools_IO.save_mat(self.denormalize(dataset[train_size:]),
filename_test_fact)
tools_IO.save_mat(
self.denormalize(numpy.array(Y_train_predicts).T),
filename_train_pred)
tools_IO.save_mat(self.denormalize(numpy.array(Y_test_predicts).T),
filename_test_pred)
if verbose == True:
tools_IO.plot_two_series(filename_train_fact,
filename_train_pred,
caption='train')
tools_IO.plot_two_series(filename_test_fact,
filename_test_pred,
caption='test')
plt.show()
return
def E2E_features_2_classes_multi_dim_train_test(self,
folder_out,
filename_train,
filename_test,
has_header=True,
has_labels_first_col=True):
tools_IO.remove_files(folder_out)
data_train = tools_IO.load_mat(filename_train, numpy.chararray, '\t')
data_test = tools_IO.load_mat(filename_test, numpy.chararray, '\t')
header, Y_train, X_train = self.preprocess_header(
data_train, has_header, has_labels_first_col=False)
header, Y_test, X_test = self.preprocess_header(
data_test, has_header, has_labels_first_col=False)
data_pos, data_neg = [], []
idx_pos_train, idx_neg_train, idx_pos_test, idx_neg_test = [], [], [], []
cnt_pos_train, cnt_neg_train, cnt_pos_test, cnt_neg_test = 0, 0, 0, 0
for x in X_train:
if x[0] > 0:
data_pos.append(x)
idx_pos_train.append(cnt_pos_train)
cnt_pos_train += 1
else:
data_neg.append(x)
idx_neg_train.append(cnt_neg_train)
cnt_neg_train += 1
offset_pos = len(data_pos)
offset_neg = len(data_neg)
for x in X_test:
if x[0] > 0:
data_pos.append(x)
idx_pos_test.append(offset_pos + cnt_pos_test)
cnt_pos_test += 1
else:
data_neg.append(x)
idx_neg_test.append(offset_neg + cnt_neg_test)
cnt_neg_test += 1
data_pos = numpy.array(data_pos)
data_neg = numpy.array(data_neg)
idx_pos_train, idx_neg_train, idx_pos_test, idx_neg_test = numpy.array(
idx_pos_train), numpy.array(idx_pos_train), numpy.array(
idx_pos_test), numpy.array(idx_neg_test)
filename_data_pos = folder_out + 'temp_pos.txt'
filename_data_neg = folder_out + 'temp_neg.txt'
tools_IO.save_mat(data_pos, filename_data_pos)
tools_IO.save_mat(data_neg, filename_data_neg)
self.learn_on_pos_neg_files(filename_data_pos,
filename_data_neg,
delimeter='\t',
rand_pos=idx_pos_train,
rand_neg=idx_neg_train,
has_header=has_header,
has_labels_first_col=has_labels_first_col)
filename_scrs_train = folder_out + 'scores_train_' + self.classifier.name + '.txt'
filename_scrs_test = folder_out + 'scores_test_' + self.classifier.name + '.txt'
self.score_feature_file(filename_train,
filename_scrs=filename_scrs_train,
delimeter='\t',
append=0,
has_header=has_header,
has_labels_first_col=has_labels_first_col)
self.score_feature_file(filename_test,
filename_scrs=filename_scrs_test,
delimeter='\t',
append=0,
has_header=has_header,
has_labels_first_col=has_labels_first_col)
self.plot_results_train_test(filename_scrs_train,
filename_scrs_test,
folder_out + 'fig_roc_train.png',
has_header=True)
th = self.get_th_train(filename_scrs_train, has_header=True)
self.draw_GT_pred(filename_scrs_train,
folder_out + 'GT_train.png',
th,
has_header=True)
self.draw_GT_pred(filename_scrs_test,
folder_out + 'GT_test.png',
th,
has_header=True)
return
