- 项目介绍
猫狗分类的图像数据集是一个广泛用于计算机视觉任务的数据集，旨在训练机器学习模型来区分猫和狗的图像。这个数据集通常包括大量的猫和狗的图像，这些图像通常已经被标记为猫或狗。
在这个项目中，我们要使用RNN也就是循环神经网络来对猫狗图像进行分类。而我为什么要采用这个方法来做呢，因为之前学的模型基本上都是卷积神经网络来做图像分类，我现在想在这个数据集上尝试一下对于猫狗数据集的分类效果。
- 模型思路使用RNN来做图像分类的思路相对于传统的卷积神经网络（CNN）来说比较新颖。其中一种方法是将RNN应用于图像的每个像素，通过学习像素之间的空间关系来预测每个像素的标签。具体而言，可以使用一种称为LSTM（长短期记忆）的RNN架构，该架构可以记住之前的上下文信息，从而更好地理解图像中像素之间的关系。在训练期间，可以使用城市景观数据集中的高分辨率图像和注释来训练模型。在测试期间，该模型可以将新的高分辨率图像输入到网络中，并输出每个像素的标签，从而实现对图像的分类。需要注意的是，由于RNN需要处理每个像素，因此它的计算成本较高，这可能会导致训练时间较长。
模型示意图如下：
def train():
opts = get_argparser_train().parse_args(args=[])
if opts.dataset.lower() == 'cityscapes':
opts.num_classes = 19
# Setup visualization
vis = Visualizer(port=opts.vis_port,
env=opts.vis_env) if opts.enable_vis else None
if vis is not None: # display options
vis.vis_table("Options", vars(opts))
os.environ['CUDA_VISIBLE_DEVICES'] = opts.gpu_id
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("Device: %s" % device)
# Setup random seed
torch.manual_seed(opts.random_seed)
np.random.seed(opts.random_seed)
random.seed(opts.random_seed)
train_dst, val_dst = get_dataset(opts)
train_loader = data.DataLoader(
train_dst, batch_size=opts.batch_size, shuffle=True, num_workers=2,
drop_last=True) # drop_last=True to ignore single-image batches.
val_loader = data.DataLoader(
val_dst, batch_size=opts.val_batch_size, shuffle=True, num_workers=2)
print("Dataset: %s, Train set: %d, Val set: %d" %
(opts.dataset, len(train_dst), len(val_dst)))
# Set up model (all models are 'constructed at network.modeling)
model = network.modeling.__dict__[opts.model](num_classes=opts.num_classes, output_stride=opts.output_stride)
if opts.separable_conv and 'plus' in opts.model:
network.convert_to_separable_conv(model.classifier)
utils.set_bn_momentum(model.backbone, momentum=0.01)
# Set up metrics
metrics = StreamSegMetrics(opts.num_classes)
# Set up optimizer
optimizer = torch.optim.SGD(params=[
{'params': model.backbone.parameters(), 'lr': 0.1 * opts.lr},
{'params': model.classifier.parameters(), 'lr': opts.lr},
], lr=opts.lr, momentum=0.9, weight_decay=opts.weight_decay)
# optimizer = torch.optim.SGD(params=model.parameters(), lr=opts.lr, momentum=0.9, weight_decay=opts.weight_decay)
# torch.optim.lr_scheduler.StepLR(optimizer, step_size=opts.lr_decay_step, gamma=opts.lr_decay_factor)
if opts.lr_policy == 'poly':
scheduler = utils.PolyLR(optimizer, opts.total_itrs, power=0.9)
elif opts.lr_policy == 'step':
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=opts.step_size, gamma=0.1)
# Set up criterion
# criterion = utils.get_loss(opts.loss_type)
if opts.loss_type == 'focal_loss':
criterion = utils.FocalLoss(ignore_index=255, size_average=True)
elif opts.loss_type == 'cross_entropy':
criterion = nn.CrossEntropyLoss(ignore_index=255, reduction='mean')
def save_ckpt(path):
""" save current model
"""
torch.save({
"cur_itrs": cur_itrs,
"model_state": model.module.state_dict(),
"optimizer_state": optimizer.state_dict(),
"scheduler_state": scheduler.state_dict(),
"best_score": best_score,
}, path)
print("Model saved as %s" % path)
utils.mkdir('./result/checkpoints')
# Restore
best_score = 0.0
cur_itrs = 0
cur_epochs = 0
if opts.ckpt is not None and os.path.isfile(opts.ckpt):
checkpoint = torch.load(opts.ckpt, map_location=torch.device('cpu'))
model.load_state_dict(checkpoint["model_state"])
model = nn.DataParallel(model)
model.to(device)
if opts.continue_training:
optimizer.load_state_dict(checkpoint["optimizer_state"])
scheduler.load_state_dict(checkpoint["scheduler_state"])
cur_itrs = checkpoint["cur_itrs"]
best_score = checkpoint['best_score']
print("Training state restored from %s" % opts.ckpt)
print("Model restored from %s" % opts.ckpt)
del checkpoint # free memory
else:
print("[!] Retrain")
model = nn.DataParallel(model)
model.to(device)
# ========== Train Loop ==========#
vis_sample_id = np.random.randint(0, len(val_loader), opts.vis_num_samples,
np.int32) if opts.enable_vis else None # sample idxs for visualization
denorm = utils.Denormalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # denormalization for ori images
if opts.test_only:
model.eval（)
val_score, ret_samples = validate(
opts=opts, model=model, loader=val_loader, device=device, metrics=metrics, ret_samples_ids=vis_sample_id)
print(metrics.to_str(val_score))
return
interval_loss = 0
while True:
# 开始训练
model.train()
cur_epochs += 1
for (images, labels) in train_loader:
cur_itrs += 1
images = images.to(device, dtype=torch.float32)
labels = labels.to(device, dtype=torch.long)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
np_loss = loss.detach().cpu().numpy()
interval_loss += np_loss
if vis is not None:
vis.vis_scalar('Loss', cur_itrs, np_loss)
if (cur_itrs) % 10 == 0:
interval_loss = interval_loss / 10
print("Epoch %d, Itrs %d/%d, Loss=%f" %
(cur_epochs, cur_itrs, opts.total_itrs, interval_loss))
interval_loss = 0.0
if (cur_itrs) % opts.val_interval == 0:
save_ckpt('./result/checkpoints/latest_%s_%s_os%d.pth' %
(opts.model, opts.dataset, opts.output_stride))
print("validation...")
model.eval（)
val_score, ret_samples = validate(
opts=opts, model=model, loader=val_loader, device=device, metrics=metrics,
ret_samples_ids=vis_sample_id)
print(metrics.to_str(val_score))
if val_score['Mean IoU'] > best_score: # save best model
best_score = val_score['Mean IoU']
save_ckpt('./result/checkpoints/best_%s_%s_os%d.pth' %
(opts.model, opts.dataset, opts.output_stride))
if vis is not None:
vis.vis_scalar("[Val] Overall Acc", cur_itrs, val_score['Overall Acc'])
vis.vis_scalar("[Val] Mean IoU", cur_itrs, val_score['Mean IoU'])
vis.vis_table("[Val] Class IoU", val_score['Class IoU'])
for k, (img, target, lbl) in enumerate(ret_samples):
img = (denorm(img) * 255).astype(np.uint8)
target = train_dst.decode_target(target).transpose(2, 0, 1).astype(np.uint8)
lbl = train_dst.decode_target(lbl).transpose(2, 0, 1).astype(np.uint8)
concat_img = np.concatenate((img, target, lbl), axis=2) # concat along width
vis.vis_image('Sample %d' % k, concat_img)
model.train()
scheduler.step()
if cur_itrs >= opts.total_itrs:
return
- 学习心得在构建过程我学习到了很多：
1. 理解序列数据：RNN适用于处理序列数据，如语音、文本和时间序列数据。学习RNN可以帮助我们更好地理解序列数据的特点和处理方法。
2. 掌握长短期记忆（LSTM）：LSTM是一种特殊类型的RNN，能够记住长序列的信息，并避免梯度消失和梯度爆炸问题。学习LSTM可以帮助我们更好地掌握RNN的核心概念和应用。
3. 实现文本生成：RNN可以用于自然语言处理任务，如文本生成和机器翻译。学习RNN可以帮助我们了解如何使用神经网络生成自然语言。
4. 图像处理：虽然CNN通常用于图像处理任务，但是RNN也可以用于图像处理，如图像分类和图像描述生成。学习RNN可以帮助我们了解如何使用神经网络处理图像数据。
- 构建以及训练在训练过程中，需要注意的是：
数据预处理：在将数据输入到神经网络之前，需要对数据进行预处理。这包括对数据进行归一化、标准化、缩放和平移等操作，以便使数据更易于处理和训练。
模型选择：不同的神经网络模型适用于不同的任务。在选择模型时，需要考虑任务的复杂性、数据的大小和类型、训练时间和计算资源等因素。
超参数调整：神经网络有许多超参数，如学习率、批量大小、迭代次数等。在训练过程中，需要对这些超参数进行调整，以便使模型更好地适应数据。
防止过拟合：过拟合是指模型在训练集上表现良好，但在测试集上表现不佳的现象。为了防止过拟合，可以使用正则化技术、dropout技术或早期停止等方法。
- 测试
最后得到的效果，分类准确率能够达到92%！！我非常激动 - Intel架构的使用在使用Intel架构进行深度学习训练时，通常会依赖深度学习框架（如TensorFlow或PyTorch）和适用于Intel架构的优化库（如Intel Math Kernel Library，MKL）。
# 导入必要的库
import tensorflow as tf
# 创建卷积神经网络模型
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activatinotallow='relu', input_shape=(224, 224, 3)),
tf.keras.layers.MaxPooling2D((2, 2)),
tf.keras.layers.Conv2D(64, (3, 3), activatinotallow='relu'),
tf.keras.layers.MaxPooling2D((2, 2)),
tf.keras.layers.Conv2D(64, (3, 3), activatinotallow='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(64, activatinotallow='relu'),
表示猫和狗两个类别
])
# 编译模型
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 准备训练数据集
X_train, y_train = load_training_data()
# 准备验证数据集
X_val, y_val = load_validation_data()
# 设置训练参数
num_epochs = 10
batch_size = 32
# 创建数据集对象
train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)).batch(batch_size)
val_dataset = tf.data.Dataset.from_tensor_slices((X_val, y_val)).batch(batch_size)
# 迭代训练
for epoch in range(num_epochs):
for batch in train_dataset:
X_batch, y_batch = batch
前向传播
predictions = model(X_batch)
计算损失
loss = model.loss(y_batch, predictions)
反向传播和参数更新
grads = tf.gradients(loss, model.trainable_variables)
model.optimizer.apply_gradients(zip(grads, model.trainable_variables))
在验证集上评估性能
val_loss, val_accuracy = model.evaluate(val_dataset, verbose=0)
print(f"Epoch {epoch+1}/{num_epochs}, Validation Loss: {val_loss}, Validation Accuracy: {val_accuracy}")
# 保存模型
model.save("trained_cnn_model") - 总结
基于Intel的开源框架能够极大地加速我们的模型训练以及模型推理。在这次比赛中，我创新的使用了RNN在做分类的任务，也创新的使用了Intel的Intel Math Kernel Library辅助，实在是一场酣畅淋漓的比赛。