def print_model_summary(network):
sample_inputs = tf.random.normal(shape=(Config.batch_size,
Config.get_image_size()[0],
Config.get_image_size()[1],
Config.image_channels))
sample_outputs = network(sample_inputs, training=True)
network.summary()
def __init__(self, batch_labels):
self.downsampling_ratio = Config.downsampling_ratio #获取网络输出的大小与网络输入的下降率
self.features_shape = np.array(
Config.get_image_size(),
dtype=np.int32) // self.downsampling_ratio #变成网络输出大小
self.batch_labels = batch_labels #batch 标签信息
self.batch_size = batch_labels.shape[0] #batch的大小
def __init__(self, original_image_size):
self.K = Config.max_boxes_per_image
self.original_image_size = np.array(original_image_size,
dtype=np.float32)
self.input_image_size = np.array(Config.get_image_size(),
dtype=np.float32)
self.downsampling_ratio = Config.downsampling_ratio
self.score_threshold = Config.score_threshold
def training_procedure(self, efficientdet_ouputs, labels):
anchors = self.anchors(image_size=Config.get_image_size())
reg_results, cls_results = efficientdet_ouputs[
..., :4], efficientdet_ouputs[..., 4:]
cls_loss_value, reg_loss_value = self.loss(cls_results, reg_results,
anchors, labels)
loss_value = tf.math.reduce_mean(cls_loss_value) + tf.reduce_mean(
reg_loss_value)
return loss_value
def testing_procedure(self, efficientdet_ouputs, input_image_size):
box_transform = BoxTransform()
clip_boxes = ClipBoxes()
map_to_original = MapToInputImage(input_image_size)
nms = NMS()
anchors = self.anchors(image_size=Config.get_image_size())
reg_results, cls_results = efficientdet_ouputs[
..., :4], efficientdet_ouputs[..., 4:]
transformed_anchors = box_transform(anchors, reg_results)
transformed_anchors = clip_boxes(transformed_anchors)
transformed_anchors = map_to_original(transformed_anchors)
scores = tf.math.reduce_max(cls_results, axis=2).numpy()
classes = tf.math.argmax(cls_results, axis=2).numpy()
final_boxes, final_scores, final_classes = nms(
boxes=transformed_anchors[0, :, :],
box_scores=np.squeeze(scores),
box_classes=np.squeeze(classes))
return final_boxes.numpy(), final_scores.numpy(), final_classes.numpy()
"D1": d1(),
"D2": d2(),
"D3": d3(),
"D4": d4(),
"D5": d5(),
"D6": d6(),
"D7": d7()
}
class CenterNet(tf.keras.Model): #CenterNet的网络架构
def __init__(self):
super(CenterNet, self).__init__()
self.backbone = backbone_zoo[Config.backbone_name]
def call(self, inputs, training=None, mask=None):
x = self.backbone(inputs, training=training)
# print("CenterNet x[0].shape:",x[0].shape," x[1].shape:",x[1].shape," x[2].shape:",x[2].shape)
x = tf.concat(values=x, axis=-1)
# print("CenterNet Out x.shape:",x.shape)
return x
if __name__ == "__main__":
print("Code is start.....")
centerNet = CenterNet()
sample_inputs = tf.random.normal(shape=(Config.batch_size, Config.get_image_size()[0], Config.get_image_size()[1], Config.image_channels))
sample_outputs = centerNet(sample_inputs, training=True)
centerNet.summary()
print("inputs.shape:",sample_inputs.shape,"outputs.shape:",sample_outputs.shape)
print("Code is running at the end.")
def __init__(self, input_image_size):
self.h, self.w = input_image_size
self.x_ratio = self.w / Config.get_image_size()[1]
self.y_ratio = self.h / Config.get_image_size()[0]
def __init__(self):
self.height, self.width = Config.get_image_size(
)[0], Config.get_image_size()[1]
class DataLoader:
input_image_height = Config.get_image_size()[0]
input_image_width = Config.get_image_size()[1]
resize_mode = Config.resize_mode
def __init__(self):
self.max_boxes_per_image = Config.max_boxes_per_image
def read_batch_data(self, batch_data):
batch_size = batch_data.shape[0]
image_file_list = []
boxes_list = []
for n in range(batch_size):
image_file, boxes = self.__get_image_information(
single_line=batch_data[n])
image_file_list.append(image_file)
boxes_list.append(boxes)
boxes = np.stack(boxes_list, axis=0)
image_tensor_list = []
for image in image_file_list:
image_tensor = DataLoader.image_preprocess(is_training=True,
image_dir=image)
image_tensor_list.append(image_tensor)
images = tf.stack(values=image_tensor_list, axis=0)
return images, boxes
def __get_image_information(self, single_line):
"""
:param single_line: tensor
:return:
image_file: string, image file dir
boxes_array: numpy array, shape = (max_boxes_per_image, 5(xmin, ymin, xmax, ymax, class_id))
"""
line_string = bytes.decode(single_line.numpy(), encoding="utf-8")
line_list = line_string.strip().split(" ")
image_file, image_height, image_width = line_list[:3]
image_height, image_width = int(float(image_height)), int(
float(image_width))
boxes = []
num_of_boxes = (len(line_list) - 3) / 5
if int(num_of_boxes) == num_of_boxes:
num_of_boxes = int(num_of_boxes)
else:
raise ValueError("num_of_boxes must be type 'int'.")
for index in range(num_of_boxes):
if index < self.max_boxes_per_image:
xmin = int(float(line_list[3 + index * 5]))
ymin = int(float(line_list[3 + index * 5 + 1]))
xmax = int(float(line_list[3 + index * 5 + 2]))
ymax = int(float(line_list[3 + index * 5 + 3]))
class_id = int(line_list[3 + index * 5 + 4])
xmin, ymin, xmax, ymax = DataLoader.box_preprocess(
image_height, image_width, xmin, ymin, xmax, ymax)
boxes.append([xmin, ymin, xmax, ymax, class_id])
num_padding_boxes = self.max_boxes_per_image - num_of_boxes
if num_padding_boxes > 0:
for i in range(num_padding_boxes):
boxes.append([0, 0, 0, 0, -1])
boxes_array = np.array(boxes, dtype=np.float32)
return image_file, boxes_array
@classmethod
def box_preprocess(cls, h, w, xmin, ymin, xmax, ymax):
if DataLoader.resize_mode == "RESIZE":
resize_ratio = [
DataLoader.input_image_height / h,
DataLoader.input_image_width / w
]
xmin = int(resize_ratio[1] * xmin)
xmax = int(resize_ratio[1] * xmax)
ymin = int(resize_ratio[0] * ymin)
ymax = int(resize_ratio[0] * ymax)
return xmin, ymin, xmax, ymax
@classmethod
def image_preprocess(cls, is_training, image_dir):
image_raw = tf.io.read_file(filename=image_dir)
decoded_image = tf.io.decode_image(contents=image_raw,
channels=3,
dtype=tf.dtypes.float32)
if DataLoader.resize_mode == "RESIZE":
decoded_image = tf.image.resize(
images=decoded_image,
size=(DataLoader.input_image_height,
DataLoader.input_image_width))
return decoded_image
def __init__(self, batch_labels):
self.downsampling_ratio = Config.downsampling_ratio
self.features_shape = np.array(
Config.get_image_size(), dtype=np.int32) // self.downsampling_ratio
self.batch_labels = batch_labels
self.batch_size = batch_labels.shape[0]
class DataLoader:
input_image_height = Config.get_image_size()[0] #获取输入图片的高度
input_image_width = Config.get_image_size()[1] #获取输入图片的宽度
input_image_channels = Config.image_channels #图片的通道数量
def __init__(self):
self.max_boxes_per_image = Config.max_boxes_per_image #最大的boxes数量
def read_batch_data(
self, batch_data
): #读取batch大小的数据，返回加载后的图片以及boxes[batch, max_boxes_per_image, xmin, ymin, xmax, ymax, class_id]
batch_size = batch_data.shape[0]
image_file_list = []
boxes_list = []
for n in range(batch_size):
image_file, boxes = self.__get_image_information(
single_line=batch_data[n])
image_file_list.append(image_file)
boxes_list.append(boxes)
boxes = np.stack(boxes_list, axis=0)
image_tensor_list = []
for image in image_file_list:
image_tensor = DataLoader.image_preprocess(is_training=True,
image_dir=image)
image_tensor_list.append(image_tensor)
images = tf.stack(values=image_tensor_list, axis=0)
return images, boxes #images为加载后的图片，boxes为[batch, max_boxes_per_image, xmin, ymin, xmax, ymax, class_id]
def __get_image_information(self, single_line):
"""
:param single_line: tensor #image_file_dir + image_height + image_width + class_ids + bbox
:return:
image_file: string, image file dir
boxes_array: numpy array, shape = (max_boxes_per_image, 5(xmin, ymin, xmax, ymax, class_id))
"""
line_string = bytes.decode(single_line.numpy(), encoding="utf-8")
line_list = line_string.strip().split(" ")
image_file, image_height, image_width = line_list[:3] #获取前三个数据量
image_height, image_width = int(float(image_height)), int(
float(image_width))
boxes = []
num_of_boxes = (len(line_list) - 3) / 5 #boxes的数量
if int(num_of_boxes) == num_of_boxes:
num_of_boxes = int(num_of_boxes)
else:
raise ValueError("num_of_boxes must be type 'int'.")
for index in range(num_of_boxes):
if index < self.max_boxes_per_image:
xmin = int(float(line_list[3 + index * 5])) #获取xmin
ymin = int(float(line_list[3 + index * 5 + 1])) #获取ymin
xmax = int(float(line_list[3 + index * 5 + 2])) #获取xmax
ymax = int(float(line_list[3 + index * 5 + 3])) #获取ymax
class_id = int(line_list[3 + index * 5 + 4]) #获取类id
xmin, ymin, xmax, ymax = DataLoader.box_preprocess(
image_height, image_width, xmin, ymin, xmax, ymax)
boxes.append([xmin, ymin, xmax, ymax, class_id])
num_padding_boxes = self.max_boxes_per_image - num_of_boxes
if num_padding_boxes > 0:
for i in range(num_padding_boxes):
boxes.append([0, 0, 0, 0, -1])
boxes_array = np.array(boxes, dtype=np.float32)
return image_file, boxes_array
@classmethod
def box_preprocess(cls, h, w, xmin, ymin, xmax, ymax): #将实际box输出为网络输出的大小
resize_ratio = [
DataLoader.input_image_height / h, DataLoader.input_image_width / w
] #是度量变化率，但是会有量化误差
xmin = int(resize_ratio[1] * xmin)
xmax = int(resize_ratio[1] * xmax)
ymin = int(resize_ratio[0] * ymin)
ymax = int(resize_ratio[0] * ymax)
return xmin, ymin, xmax, ymax
@classmethod
def image_preprocess(cls, is_training, image_dir): #对图片进行处理以及加载
image_raw = tf.io.read_file(filename=image_dir)
decoded_image = tf.io.decode_image(
contents=image_raw,
channels=DataLoader.input_image_channels,
dtype=tf.dtypes.float32)
decoded_image = tf.image.resize(images=decoded_image,
size=(DataLoader.input_image_height,
DataLoader.input_image_width))
return decoded_image
