Verwenden Sie train_on_batch, um den Trainingsprozess genau zu verwalten
Die meisten Schüler, die Keras verwenden, verwenden fit() oder fit_generator() für das Modelltraining. Diese beiden APIs sind sehr benutzerfreundlich und praktisch für Schüler, die neu im Deep Learning sind, aber da es sich um sehr tiefe Pakete handelt, sind sie für diejenigen geeignet, die das Training anpassen möchten Prozess Es ist für Studenten nicht so praktisch (Studenten, die von Torch zu Keras wechseln, ziehen es möglicherweise vor, den Trainingsprozess anzupassen), und für GAN, ein Modell, das ein schrittweises Training erfordert, kann es nicht direkt mit fit oder fit_generator trainiert werden . Daher stellt Keras die API train_on_batch bereit, um den Gradienten von Mini-Batch-Daten zu aktualisieren.
Die Vorteile lassen sich wie folgt zusammenfassen:
- Verfeinerter benutzerdefinierter Trainingsprozess, genauere Erfassung von Verlusten und Kennzahlen
- Schritt-für-Schritt-Trainingsmodell – Implementierung von GAN
- Multi-GPU-Trainings- und Speichermodelle sind bequemer
- Vielfältigere Methoden zum Laden von Daten, kombiniert mit der Verwendung eines Brenner-Datenladers
Im Folgenden wird die Verwendung von train_on_batch beschrieben
1. Eingabe und Ausgabe von train_on_batch
1.1 Eingabe
y_pred = Model.train_on_batch(
x,
y=None,
sample_weight=None,
class_weight=None,
reset_metrics=True,
return_dict=False,
)
- x: Modelleingabe, eine einzelne Eingabe ist ein Numpy-Array und mehrere Eingaben sind eine Liste von Numpy-Arrays
- y: Label, das Single-Output-Modell ist ein Numpy-Array, das Multi-Output-Modell ist eine Liste von Numpy-Arrays
- Sample_weight: Das Gewicht, das jeder Probe im Mini-Batch entspricht, die Form ist (batch_size)
- class_weight: Kategoriegewicht, das auf die Verlustfunktion einwirkt und dem Verlust jeder Kategorie Gewicht hinzufügt. Wird hauptsächlich bei unausgeglichenen Kategorien verwendet. Die Form ist (num_classes).
- reset_metrics: Der Standardwert ist „True“, die zurückgegebenen Metriken gelten nur für diesen Mini-Batch. Bei „Falsch“ werden die Metriken über Batches hinweg akkumuliert
- return_dict: Standardwert False, y_pred ist eine Liste . Wenn True, ist y_pred ein Wörterbuch
1.2 Ausgabe
- Einzelausgabemodell, 1 Verlust, keine Metriken, train_on_batch gibt einen Skalar zurück , der beispielsweise den Verlust dieses Mini-Batchs darstellt
model = keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(Adam, loss=['binary_crossentropy'])
y_pred = model.train_on_batch(x=image,y=label)
# y_pred 为标量
- Einzelausgabemodell, mit 1 Verlust, n Metriken, train_on_batch gibt eine Liste zurück , die Länge der Liste beträgt beispielsweise 1+n
model = keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(Adam, loss=['binary_crossentropy'], metrics=['accuracy'])
y_pred = model.train_on_batch(x=image,y=label)
# len(y_pred) == 2, y_pred[0]为loss， y_pred[1]为accuracy
- Multi-Output-Modell, n Verlust, m Metriken, train_on_batch gibt eine Liste zurück , die Länge der Liste beträgt beispielsweise 1+n+m*n
model = keras.models.Model(inputs=inputs, outputs=[output1, output2])
model.compile(Adam,
loss=['binary_crossentropy', 'binary_crossentropy'],
metrics=['accuracy', 'accuracy'])
y_pred = model.train_on_batch(x=image,y=label)
# 查看model.metrics_names来了解返回列表中每个值的含义
2. train_on_batch Multi-GPU-Trainingsmodell
2.1 Multi-GPU-Modellinitialisierung, Laden von Gewichten, Modellkompilierung, Modellspeicherung
Notiz! Arbeiten Sie während des Trainings mit para_model und beim Speichern mit dem Modell
import tensorflow as tf
import keras
import os
# 初始化GPU的使用个数
gpu = "0,1"
os.environ["CUDA_VISIBLE_DEVICES"] = gpu
gpu_num = len(gpu.split(','))
# model初始化
with tf.device('/cpu:0'):# 使用多GPU时，先在CPU上初始化模型
model = YourModel(input_size, num_classes)
model.load_weights('*.h5') # 如果有权重需要加载，在这里实现
para_model = keras.utils.multi_gpu_model(model, gpus=gpu_num) # 在GPU上初始化多GPU模型
para_model.compile(optimizer, loss=[...], metrics=[...]) # 编译多GPU模型
# 训练和验证，对 para_model 使用 train_on_batch
def train():
para_model.train_on_batch(...)
def evaluate():
para_model.test_on_batch(...)
# 保存模型，注意！训练时对 para_model 操作，保存时对 model 做操作
# 不要使用 para_model.save() 或者 para_model.save_weights()，否则加载时会出问题
model.save('*.h5')
model.save_weights('*.h5')
3. Benutzerdefinierte Strategie zur Anpassung der Lernrate
Da Rückrufe nicht verwendet werden können, verwenden wir keras.backend.get_value() und keras.backend.set_value(), um die aktuelle Lernrate abzurufen und festzulegen. Implementieren wir beispielsweise die einfachste Step-Down-Lernrate. Alle 10 Epochen sinkt die Lernrate um das 0,1-fache
import keras.backend as K
for epoch in range(100):
train_one_epoch()
evaluate()
# 每10个epoch，lr缩小0.1倍
if epoch%10==0 and epoch!=0:
lr = K.get_value(model.optimizer.lr) # 获取当前学习率
lr = lr * 0.1 # 学习率缩小0.1倍
K.set_value(model.optimizer.lr, lr) # 设置学习率
4. Kombination aus Keras und Fackel
Der Dataloader von Torch ist die beste Methode zum Laden von Daten, die ich bisher verwendet habe. Ein Grund für die Verwendung von train_on_batch liegt darin, dass ich den Torch-Dataloader zum Laden von Daten und dann train_on_batch zum Trainieren des Modells verwenden kann. Durch eine angemessene Steuerung der Verwendung von CPU-Workern Größe der Zahl und Batch_Size maximiert die Trainingseffizienz des Modells
4.1 Dataloader + Train_on_Batch trainiert die Keras-Modellpipeline
# 定义 torch dataset
class Dataset(torch.utils.data.Dataset):
def __init__(self, root_list, transforms=None):
self.root_list = root_list
self.transforms = transforms
def __getitem__(self, idx):
# 假设是图像分类任务
image = ... # 读取单张图像
label = ... # 读取标签
if self.transforms is not None:
image = self.transforms(image)
return image, label # shape: (H,W,3), salar
def __len__(self):
return len(self.root_list)
# 自定义 collate_fn 使 dataloader 返回 numpy array
def collate_fn(batch):
# 这里的 batch 是 tuple 列表，[(image, label),(image, label),...]
image, label = zip(*batch)
image = np.asarray(image) # (batch_size, H, W, 3)
label = np.asarray(label) # (batch_size)
return image, label # 如果 datast 返回的图像是 ndarray，这样loader返回的也是 ndarray
# 定义dataset
train_dataset = Dataset(train_list)
valid_dataset = Dataset(valid_list)
test_dataset = Dataset(test_list)
# 定义 dataloader, 如果不使用自定义 collate_fn,
# 从 loader 取出的默认是 torch Tensor，需要做一个 .numpy()的转换
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size, shuffle=True, num_workers=4, collate_fn=collate_fn)
valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size, shuffle=False, num_workers=4, collate_fn=collate_fn)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size, shuffle=False, num_workers=4, collate_fn=collate_fn)
# 定义 train，evaluate，test
def train():
for i,(inputs, label) in enumerate(train_loader):
# 如果 inputs 和 label 是 torch Tensor
# 请用 inputs = inputs.numpy() 和 label = label.numpy() 转成 ndarray
y_pred = model.train_on_batch(inputs, label)
def evaluate():
for i,(inputs, label) in enumerate(valid_loader):
# 如果 inputs 和 label 是 Tensor，同上
y_pred = model.test_on_batch(inputs, label)
def test():
for i,(inputs, label) in enumerate(test_loader):
# 如果 inputs 和 label 是 Tensor，同上
y_pred = model.test_on_batch(inputs, label)
def run():
for epoch in num_epoch:
train()
evaluate()
test()
if __name__ == "__main__":
run()
Zusammenfassen
Es gibt auch einige Orte, an denen train_on_batch verwendet wird, z. B. das GAN-Training, das hier nicht vorgestellt wird. Für Details können Sie auf Github suchen, z. B. keras-dcgan .