def create_model(input_shape,
anchors,
num_classes,
weights_path='model_data/yolo_weights.h5'):
'''create the training model'''
K.clear_session() # get a new session
image_input = Input(shape=(None, None, 3))
h, w = input_shape
num_anchors = len(anchors)
y_true = [Input(shape=(h//{0:32, 1:16, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \
num_anchors//3, num_classes+5)) for l in range(3)]
model_body = yolo_body(image_input, num_anchors // 3, num_classes)
print('Create YOLOv3 model with {} anchors and {} classes.'.format(
num_anchors, num_classes))
model_loss = Lambda(yolo_loss,
output_shape=(1, ),
name='yolo_loss',
arguments={
'anchors': anchors,
'num_classes': num_classes,
'ignore_thresh': 0.5
})([*model_body.output, *y_true])
model = Model([model_body.input, *y_true], model_loss)
return model
def generate(self):
num_anchors = len(self.anchors)
num_classes = len(self.classes_names)
print("num_anchors", num_anchors)
print("num_classes", num_classes)
print("anchors", self.anchors)
# print("classes",self.classes)
self.yolo_model = yolo_body(Input(shape=(None, None, 3)),
num_anchors // 3, num_classes)
self.yolo_model.summary()
self.yolo_model.load_weights(self.model_path)
# self.yolo_model=load_model(self.model_path,compile=False)
print("model loaded...")
"生成边框颜色"
hsv_tuples = [(x / len(self.classes_names), 1., 1.)
for x in range(len(self.classes_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101)
np.random.shuffle(self.colors)
np.random.seed(None)
self.input_image_shape = K.placeholder(shape=(2, ))
print(self.yolo_model.output[0].shape, self.yolo_model.output[1].shape,
self.yolo_model.output[2].shape)
boxes, score, classes = yolo_eval(self.yolo_model.output,
self.anchors,
num_classes,
self.input_image_shape,
score_threshold=self.score,
iou_threshold=self.iou)
return boxes, score, classes
def load_model(self):
"""
加载模型
:return:
"""
model = yolo_body()
print("loading weights...")
model.load_weights(self.model_path)
self.model = model
def high_level_train(optimizer, loss, train_datasets, valid_datasets, train_steps, valid_steps):
"""
使用fit方式训练，可以知道训练完的时间，以及更规范的添加callbacks参数
:param optimizer: 优化器
:param loss: 自定义的loss function
:param train_datasets: 以tf.data封装好的训练集数据
:param valid_datasets: 验证集数据
:param train_steps: 迭代一个epoch的轮次
:param valid_steps: 同上
:return: None
"""
callbacks = [
ReduceLROnPlateau(verbose=1),
EarlyStopping(patience=10, verbose=1),
TensorBoard(log_dir=cfg.log_dir),
ModelCheckpoint(cfg.best_model, save_best_only=True, save_weights_only=True)
]
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
model = yolo_body()
model.compile(optimizer=optimizer, loss=loss)
# initial_epoch用于恢复之前的训练
model.fit(train_datasets,
steps_per_epoch=max(1, train_steps),
validation_data=valid_datasets,
validation_steps=max(1, valid_steps),
epochs=cfg.epochs,
initial_epoch=0,
callbacks=callbacks)
print("save weights")
model.save_weights(cfg.model_path)
if cfg.fine_tune:
with strategy.scope():
print("Unfreeze all of the layers.")
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=Adam(learning_rate=cfg.learn_rating / 10), loss=loss)
model.fit(train_datasets,
steps_per_epoch=max(1, train_steps),
validation_data=valid_datasets,
validation_steps=max(1, valid_steps),
epochs=cfg.epochs*2,
initial_epoch=cfg.epochs + 1,
callbacks=callbacks)
print("save weights")
model.save_weights(cfg.model_path)
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith(
'.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors == 6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
#self.yolo_model.load_weights('/content/drive/My Drive/ep020-loss18.266-val_loss18.436.h5')
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(
self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(
self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num >= 2:
self.yolo_model = multi_gpu_model(self.yolo_model,
gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output,
self.anchors,
len(self.class_names),
self.input_image_shape,
score_threshold=self.score,
iou_threshold=self.iou)
return boxes, scores, classes
def create_model(input_shape,
anchors,
num_classes,
load_pretrained=True,
freeze_body=2,
weights_path="../data/yolo_weights1.h5"):
K.clear_session()
image_imput = Input(shape=(None, None, 3))
h, w = input_shape
num_anchors = len(anchors)
y_true = [
Input(shape=(h // {
0: 32,
1: 16,
2: 8
}[l], w // {
0: 32,
1: 16,
2: 8
}[l], num_anchors // 3, num_classes + 5)) for l in range(3)
]
model_body = yolo_body(image_imput, num_anchors // 3, num_classes)
print("Created YOLOV3 model")
if load_pretrained:
model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)
print("load weight...")
if freeze_body in [1, 2]:
num = (185, len(model_body.layers) - 3)[freeze_body - 1]
for i in range(num):
model_body.layers[i].trainable = False
print("free model layer")
model_loss = Lambda(yolo_loss,
output_shape=(1, ),
name="yolo_loss",
arguments={
"anchors": anchors,
"num_classes": num_classes,
"ignore_thresh": 0.5
})([*model_body.output, *y_true])
model = Model([model_body.input, *y_true], model_loss)
return model
def create_model(input_shape,
anchors,
num_classes,
load_pretrained=True,
freeze_body=2,
weights_path=DARKNET_WEIGHT_PATH):
'''create the training model'''
K.clear_session() # get a new session
image_input = Input(shape=(None, None, 3))
h, w = input_shape
num_anchors = len(anchors)
y_true = [Input(shape=(h//{0:32, 1:16, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \
num_anchors//3, num_classes+5)) for l in range(3)]
model_body = yolo_body(image_input, num_anchors // 3, num_classes)
print('Create YOLOv3 model with {} anchors and {} classes.'.format(
num_anchors, num_classes))
if load_pretrained:
model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)
print('Load weights {}.'.format(weights_path))
if freeze_body in [1, 2]:
# Freeze darknet53 body or freeze all but 3 output layers.
num = (185, len(model_body.layers) - 3)[freeze_body - 1]
for i in range(num):
model_body.layers[i].trainable = False
print('Freeze the first {} layers of total {} layers.'.format(
num, len(model_body.layers)))
model_loss = Lambda(yolo_loss,
output_shape=(1, ),
name='yolo_loss',
arguments={
'anchors': anchors,
'num_classes': num_classes,
'ignore_thresh': 0.5
})([*model_body.output, *y_true])
model = Model([model_body.input, *y_true], model_loss)
return model
def low_level_train(optimizer, yolo_loss, train_datasets, valid_datasets, train_steps, valid_steps):
"""
以底层的方式训练，这种方式更好地观察训练过程，监视变量的变化
:param optimizer: 优化器
:param yolo_loss: 自定义的loss function
:param train_datasets: 以tf.data封装好的训练集数据
:param valid_datasets: 验证集数据
:param train_steps: 迭代一个epoch的轮次
:param valid_steps: 同上
:return: None
"""
# 创建模型结构
model = yolo_body()
# 定义模型评估指标
train_loss = Mean(name='train_loss')
valid_loss = Mean(name='valid_loss')
# 设置保存最好模型的指标
best_test_loss = float('inf')
patience = 10
min_delta = 1e-3
patience_cnt = 0
history_loss = []
# 创建summary
summary_writer = tf.summary.create_file_writer(logdir=cfg.log_dir)
# low level的方式计算loss
for epoch in range(1, cfg.epochs + 1):
train_loss.reset_states()
valid_loss.reset_states()
step = 0
print("Epoch {}/{}".format(epoch, cfg.epochs))
# 处理训练集数据
for batch, (images, labels) in enumerate(train_datasets.take(train_steps)):
with tf.GradientTape() as tape:
# 得到预测
outputs = model(images, training=True)
# 计算损失(注意这里收集model.losses的前提是Conv2D的kernel_regularizer参数)
regularization_loss = tf.reduce_sum(model.losses)
pred_loss = []
# yolo_loss、label、output都是3个特征层的数据，通过for 拆包之后，一个loss_fn就是yolo_loss中一个特征层
# 然后逐一计算,
for output, label, loss_fn in zip(outputs, labels, yolo_loss):
pred_loss.append(loss_fn(label, output))
# 总损失 = yolo损失 + 正则化损失
total_train_loss = tf.reduce_sum(pred_loss) + regularization_loss
# 反向传播梯度下降
# model.trainable_variables代表把loss反向传播到每个可以训练的变量中
grads = tape.gradient(total_train_loss, model.trainable_variables)
# 将每个节点的误差梯度gradients，用于更新该节点的可训练变量值
# zip是把梯度和可训练变量值打包成元组
optimizer.apply_gradients(zip(grads, model.trainable_variables))
# 更新train_loss
train_loss.update_state(total_train_loss)
# 输出训练过程
rate = (step + 1) / train_steps
a = "*" * int(rate * 70)
b = "." * int((1 - rate) * 70)
loss = train_loss.result().numpy()
print("\r{}/{} {:^3.0f}%[{}->{}] - loss:{:.4f}".
format(batch, train_steps, int(rate * 100), a, b, loss), end='')
step += 1
# 计算验证集
for batch, (images, labels) in enumerate(valid_datasets.take(valid_steps)):
# 得到预测，不training
outputs = model(images)
regularization_loss = tf.reduce_sum(model.losses)
pred_loss = []
for output, label, loss_fn in zip(outputs, labels, yolo_loss):
pred_loss.append(loss_fn(label, output))
total_valid_loss = tf.reduce_sum(pred_loss) + regularization_loss
# 更新valid_loss
valid_loss.update_state(total_valid_loss)
print('\nLoss: {:.4f}, Test Loss: {:.4f}\n'.format(train_loss.result(), valid_loss.result()))
# 保存loss，可以选择train的loss
history_loss.append(valid_loss.result().numpy())
# 保存到tensorboard里
with summary_writer.as_default():
tf.summary.scalar('train_loss', train_loss.result(), step=optimizer.iterations)
tf.summary.scalar('valid_loss', valid_loss.result(), step=optimizer.iterations)
# 只保存最好模型
if valid_loss.result() < best_test_loss:
best_test_loss = valid_loss.result()
model.save_weights(cfg.model_path, save_format='tf')
# EarlyStopping
if epoch > 1 and history_loss[epoch - 2] - history_loss[epoch - 1] > min_delta:
patience_cnt = 0
else:
patience_cnt += 1
if patience_cnt >= patience:
tf.print("No improvement for {} times, early stopping optimization.".format(patience))
break
class_loss = tf.reduce_sum(class_loss) / tf.cast(
batch_size, tf.float32)
if summary_writer:
# 保存到tensorboard里
with summary_writer.as_default():
tf.summary.scalar('xy_loss',
xy_loss,
step=optimizer.iterations)
tf.summary.scalar('wh_loss',
wh_loss,
step=optimizer.iterations)
tf.summary.scalar('confidence_loss',
confidence_loss,
step=optimizer.iterations)
tf.summary.scalar('class_loss',
class_loss,
step=optimizer.iterations)
return xy_loss + wh_loss + confidence_loss + class_loss
return compute_loss
if __name__ == '__main__':
import numpy as np
inputs = tf.keras.layers.Input(shape=(416, 416, 3), dtype="float32")
model = yolo_body()