网站首页html代码的,portfolio wordpress,宁波网络营销咨询,关键词搜索工具app基于WIN10的64位系统演示
一、写在前面
本期#xff0c;我们继续学习深度学习图像目标检测系列#xff0c;SSD#xff08;Single Shot MultiBox Detector#xff09;模型的后续版本#xff0c;SSDlite模型。 二、SSDlite简介
SSDLite 是 SSD 模型的一个变种#xff0c…基于WIN10的64位系统演示
一、写在前面
本期我们继续学习深度学习图像目标检测系列SSDSingle Shot MultiBox Detector模型的后续版本SSDlite模型。 二、SSDlite简介
SSDLite 是 SSD 模型的一个变种旨在为移动设备和边缘计算设备提供更高效的目标检测。SSDLite 的主要特点是使用了轻量级的骨干网络和特定的卷积操作来减少计算复杂性从而提高检测速度同时在大多数情况下仍保持了较高的准确性。
以下是 SSDLite 的主要特性和组件
1轻量级骨干
SSDLite 不使用 VGG 或 ResNet 这样的重量级骨干。相反它使用 MobileNet 作为骨干特别是 MobileNetV2 或 MobileNetV3。这些网络使用深度可分离的卷积和其他轻量级操作来减少计算成本。
2深度可分离的卷积
这是 MobileNet 的核心组件也被用于 SSDLite。深度可分离的卷积将传统的卷积操作分解为两个较小的操作一个深度卷积和一个点卷积这大大减少了计算和参数数量。
3多尺度特征映射
与原始的 SSD 相似SSDLite 也从不同的层级提取特征图以检测不同大小的物体。
4默认框
SSDLite 也使用默认框或称为锚框来进行边界框预测。
5单阶段检测
与 SSD 相同SSDLite 也是一个单阶段检测器同时进行边界框回归和分类。
6损失函数
SSDLite 使用与 SSD 相同的组合损失包括平滑 L1 损失和交叉熵损失。
综上SSDLite 是为了速度和效率而设计的特别是针对计算和内存资源有限的设备。通过使用轻量级的骨干和深度可分离的卷积它能够在减少计算负担的同时仍然保持合理的检测准确性。 三、数据源
来源于公共数据文件设置如下 大概的任务就是用一个框框标记出MTB的位置。 四、SSDlite实战
直接上代码
import os
import random
import torch
import torchvision
from torchvision.models.detection import ssdlite320_mobilenet_v3_large
from torchvision.transforms import functional as F
from PIL import Image
from torch.utils.data import DataLoader
import xml.etree.ElementTree as ET
import matplotlib.pyplot as plt
from torchvision import transforms
import albumentations as A
from albumentations.pytorch import ToTensorV2
import numpy as np# Function to parse XML annotations
def parse_xml(xml_path):tree ET.parse(xml_path)root tree.getroot()boxes []for obj in root.findall(object):bndbox obj.find(bndbox)xmin int(bndbox.find(xmin).text)ymin int(bndbox.find(ymin).text)xmax int(bndbox.find(xmax).text)ymax int(bndbox.find(ymax).text)# Check if the bounding box is validif xmin xmax and ymin ymax:boxes.append((xmin, ymin, xmax, ymax))else:print(fWarning: Ignored invalid box in {xml_path} - ({xmin}, {ymin}, {xmax}, {ymax}))return boxes# Function to split data into training and validation sets
def split_data(image_dir, split_ratio0.8):all_images [f for f in os.listdir(image_dir) if f.endswith(.jpg)]random.shuffle(all_images)split_idx int(len(all_images) * split_ratio)train_images all_images[:split_idx]val_images all_images[split_idx:]return train_images, val_images# Dataset class for the Tuberculosis dataset
class TuberculosisDataset(torch.utils.data.Dataset):def __init__(self, image_dir, annotation_dir, image_list, transformNone):self.image_dir image_dirself.annotation_dir annotation_dirself.image_list image_listself.transform transformdef __len__(self):return len(self.image_list)def __getitem__(self, idx):image_path os.path.join(self.image_dir, self.image_list[idx])image Image.open(image_path).convert(RGB)xml_path os.path.join(self.annotation_dir, self.image_list[idx].replace(.jpg, .xml))boxes parse_xml(xml_path)# Check for empty bounding boxes and return Noneif len(boxes) 0:return Noneboxes torch.as_tensor(boxes, dtypetorch.float32)labels torch.ones((len(boxes),), dtypetorch.int64)iscrowd torch.zeros((len(boxes),), dtypetorch.int64)target {}target[boxes] boxestarget[labels] labelstarget[image_id] torch.tensor([idx])target[iscrowd] iscrowd# Apply transformationsif self.transform:image self.transform(image)return image, target# Define the transformations using torchvision
data_transform torchvision.transforms.Compose([torchvision.transforms.ToTensor(), # Convert PIL image to tensortorchvision.transforms.Normalize(mean[0.485, 0.456, 0.406], std[0.229, 0.224, 0.225]) # Normalize the images
])# Adjusting the DataLoader collate function to handle None values
def collate_fn(batch):batch list(filter(lambda x: x is not None, batch))return tuple(zip(*batch))def get_ssdlite_model_for_finetuning(num_classes):# Load an SSDlite model with a MobileNetV3 Large backbone without pre-trained weightsmodel ssdlite320_mobilenet_v3_large(pretrainedFalse, num_classesnum_classes)return model# Function to save the model
def save_model(model, pathSSDlite_mtb.pth, save_full_modelFalse):if save_full_model:torch.save(model, path)else:torch.save(model.state_dict(), path)print(fModel saved to {path})# Function to compute Intersection over Union
def compute_iou(boxA, boxB):xA max(boxA[0], boxB[0])yA max(boxA[1], boxB[1])xB min(boxA[2], boxB[2])yB min(boxA[3], boxB[3])interArea max(0, xB - xA 1) * max(0, yB - yA 1)boxAArea (boxA[2] - boxA[0] 1) * (boxA[3] - boxA[1] 1)boxBArea (boxB[2] - boxB[0] 1) * (boxB[3] - boxB[1] 1)iou interArea / float(boxAArea boxBArea - interArea)return iou# Adjusting the DataLoader collate function to handle None values and entirely empty batches
def collate_fn(batch):batch list(filter(lambda x: x is not None, batch))if len(batch) 0:# Return placeholder batch if entirely emptyreturn [torch.zeros(1, 3, 224, 224)], [{}]return tuple(zip(*batch))#Training function with modifications for collecting IoU and loss
def train_model(model, train_loader, optimizer, device, num_epochs10):model.train()model.to(device)loss_values []iou_values []for epoch in range(num_epochs):epoch_loss 0.0total_ious 0num_boxes 0for images, targets in train_loader:# Skip batches with placeholder dataif len(targets) 1 and not targets[0]:continue# Skip batches with empty targetsif any(len(target[boxes]) 0 for target in targets):continueimages [image.to(device) for image in images]targets [{k: v.to(device) for k, v in t.items()} for t in targets]loss_dict model(images, targets)losses sum(loss for loss in loss_dict.values())optimizer.zero_grad()losses.backward()optimizer.step()epoch_loss losses.item()# Compute IoU for evaluationwith torch.no_grad():model.eval()predictions model(images)for i, prediction in enumerate(predictions):pred_boxes prediction[boxes].cpu().numpy()true_boxes targets[i][boxes].cpu().numpy()for pred_box in pred_boxes:for true_box in true_boxes:iou compute_iou(pred_box, true_box)total_ious iounum_boxes 1model.train()avg_loss epoch_loss / len(train_loader)avg_iou total_ious / num_boxes if num_boxes ! 0 else 0loss_values.append(avg_loss)iou_values.append(avg_iou)print(fEpoch {epoch1}/{num_epochs} Loss: {avg_loss} Avg IoU: {avg_iou})# Plotting loss and IoU valuesplt.figure(figsize(12, 5))plt.subplot(1, 2, 1)plt.plot(loss_values, labelTraining Loss)plt.title(Training Loss across Epochs)plt.xlabel(Epochs)plt.ylabel(Loss)plt.subplot(1, 2, 2)plt.plot(iou_values, labelIoU)plt.title(IoU across Epochs)plt.xlabel(Epochs)plt.ylabel(IoU)plt.show()# Save model after trainingsave_model(model)# Validation function
def validate_model(model, val_loader, device):model.eval()model.to(device)with torch.no_grad():for images, targets in val_loader:images [image.to(device) for image in images]targets [{k: v.to(device) for k, v in t.items()} for t in targets]model(images)# Paths to your data
image_dir tuberculosis-phonecamera
annotation_dir tuberculosis-phonecamera# Split data
train_images, val_images split_data(image_dir)# Create datasets and dataloaders
train_dataset TuberculosisDataset(image_dir, annotation_dir, train_images, transformdata_transform)
val_dataset TuberculosisDataset(image_dir, annotation_dir, val_images, transformdata_transform)# Updated DataLoader with new collate function
train_loader DataLoader(train_dataset, batch_size4, shuffleTrue, collate_fncollate_fn)
val_loader DataLoader(val_dataset, batch_size4, shuffleFalse, collate_fncollate_fn)# Model and optimizer
model get_ssdlite_model_for_finetuning(2)
optimizer torch.optim.Adam(model.parameters(), lr0.001)# Train and validate
train_model(model, train_loader, optimizer, devicecuda, num_epochs10)
validate_model(model, val_loader, devicecuda)
需要从头训练的就不跑了摆烂了。 五、写在后面
目标检测模型门槛更高了运行起来对硬件要求也很高时间也很久都是小时起步的。因此只是简单介绍算是入个门了。
