问题描述
我有pytorch 1.7。以下代码与 Object detection and finetuning.
data_loader = torch.utils.data.DataLoader(dataset,batch_size=2,shuffle=True,num_workers=4,collate_fn=utils.collate_fn)
作为NameError: name 'utils' is not defined
可能有什么问题？
整个代码如下。
import os
import numpy as np
import torch
from PIL import Image
class PrepareDataset(object):
def __init__(self,root,transforms):
self.root = root
self.transforms = transforms
# load all image files,sorting them to
# ensure that they are aligned
self.imgs = list(sorted(os.listdir(os.path.join(root,"images"))))
self.masks = list(sorted(os.listdir(os.path.join(root,"masks"))))
self.annotations = list(sorted(os.listdir(os.path.join(root,"annotations"))))
def __getitem__(self,idx):
# load images ad masks
img_path = os.path.join(self.root,"images",self.imgs[idx])
mask_path = os.path.join(self.root,"masks",self.masks[idx])
annotation_path = os.path.join(self.root,"annotations",self.annotations[idx])
img = Image.open(img_path).convert("RGB")
# note that we haven't converted the mask to RGB,# because each color corresponds to a different instance
# with 0 being background
mask = Image.open(mask_path)
# convert the PIL Image into a numpy array
mask = np.array(mask)
# instances are encoded as different colors
obj_ids = np.unique(mask)
# first id is the background,so remove it
obj_ids = obj_ids[1:]
# split the color-encoded mask into a set
# of binary masks
masks = mask == obj_ids[:,None,None]
# get bounding Box coordinates for each mask
num_objs = len(obj_ids)
Boxes = []
for i in range(num_objs):
pos = np.where(masks[i])
xmin = np.min(pos[1])
xmax = np.max(pos[1])
ymin = np.min(pos[0])
ymax = np.max(pos[0])
Boxes.append([xmin,ymin,xmax,ymax])
# convert everything into a torch.Tensor
Boxes = torch.as_tensor(Boxes,dtype=torch.float32)
# there is only one class
labels = torch.ones((num_objs,),dtype=torch.int64)
masks = torch.as_tensor(masks,dtype=torch.uint8)
image_id = torch.tensor([idx])
area = (Boxes[:,3] - Boxes[:,1]) * (Boxes[:,2] - Boxes[:,0])
# suppose all instances are not crowd
iscrowd = torch.zeros((num_objs,dtype=torch.int64)
target = {}
target["Boxes"] = Boxes
target["labels"] = labels
target["masks"] = masks
target["image_id"] = image_id
target["area"] = area
target["iscrowd"] = iscrowd
if self.transforms is not None:
img,target = self.transforms(img,target)
return img,target
def __len__(self):
return len(self.imgs)
import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
# load a model pre-trained pre-trained on COCO
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
# replace the classifier with a new one,that has
# num_classes which is user-defined
num_classes = 2 # 1 class (person) + background
# get number of input features for the classifier
in_features = model.roi_heads.Box_predictor.cls_score.in_features
# replace the pre-trained head with a new one
model.roi_heads.Box_predictor = FastRCNNPredictor(in_features,num_classes)
import torchvision
from torchvision.models.detection import FasterRCNN
from torchvision.models.detection.rpn import AnchorGenerator
# load a pre-trained model for classification and return
# only the features
backbone = torchvision.models.mobilenet_v2(pretrained=True).features
# FasterRCNN needs to kNow the number of
# output channels in a backbone. For mobilenet_v2,it's 1280
# so we need to add it here
backbone.out_channels = 1280
# let's make the rpn generate 5 x 3 anchors per spatial
# location,with 5 different sizes and 3 different aspect
# ratios. We have a Tuple[Tuple[int]] because each feature
# map Could potentially have different sizes and
# aspect ratios
anchor_generator = AnchorGenerator(sizes=((32,64,128,256,512),aspect_ratios=((0.5,1.0,2.0),))
# let's define what are the feature maps that we will
# use to perform the region of interest cropping,as well as
# the size of the crop after rescaling.
# if your backbone returns a Tensor,featmap_names is expected to
# be [0]. More generally,the backbone should return an
# OrderedDict[Tensor],and in featmap_names you can choose which
# feature maps to use.
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],output_size=7,sampling_ratio=2)
# put the pieces together inside a FasterRCNN model
model = FasterRCNN(backbone,num_classes=5,rpn_anchor_generator=anchor_generator,Box_roi_pool=roi_pooler)
import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor
def get_model_instance_segmentation(num_classes):
# load an instance segmentation model pre-trained pre-trained on COCO
model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
# get number of input features for the classifier
in_features = model.roi_heads.Box_predictor.cls_score.in_features
# replace the pre-trained head with a new one
model.roi_heads.Box_predictor = FastRCNNPredictor(in_features,num_classes)
# Now get the number of input features for the mask classifier
in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
hidden_layer = 256
# and replace the mask predictor with a new one
model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,hidden_layer,num_classes)
return model
from torchvision import transforms as T
def get_transform(train):
transforms = []
transforms.append(T.ToTensor())
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
return T.Compose(transforms)
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
dataset = PrepareDataset('/home/centos/atic-nyan/Traffic',get_transform(train=True))
data_loader = torch.utils.data.DataLoader(dataset,collate_fn=utils.collate_fn)
# For Training
images,targets = next(iter(data_loader))
images = list(image for image in images)
targets = [{k: v for k,v in t.items()} for t in targets]
output = model(images,targets) # Returns losses and detections
# For inference
model.eval()
x = [torch.rand(3,300,400),torch.rand(3,500,400)]
predictions = model(x) # Returns predictions
from engine import train_one_epoch,evaluate
import utils
def main():
# train on the GPU or on the cpu,if a GPU is not available
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
# our dataset has two classes only - background and person
num_classes = 2
# use our dataset and defined transformations
dataset = PrepareDataset('/home/centos/atic-nyan/Traffic',get_transform(train=True))
dataset_test = PrepareDataset('/home/centos/atic-nyan/Traffic',get_transform(train=False))
# split the dataset in train and test set
indices = torch.randperm(len(dataset)).tolist()
dataset = torch.utils.data.Subset(dataset,indices[:-50])
dataset_test = torch.utils.data.Subset(dataset_test,indices[-50:])
# define training and validation data loaders
data_loader = torch.utils.data.DataLoader(
dataset,collate_fn=utils.collate_fn)
data_loader_test = torch.utils.data.DataLoader(
dataset_test,batch_size=1,shuffle=False,collate_fn=utils.collate_fn)
# get the model using our helper function
model = get_model_instance_segmentation(num_classes)
# move model to the right device
model.to(device)
# construct an optimizer
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params,lr=0.005,momentum=0.9,weight_decay=0.0005)
# and a learning rate scheduler
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=3,gamma=0.1)
# let's train it for 10 epochs
num_epochs = 10
for epoch in range(num_epochs):
# train for one epoch,printing every 10 iterations
train_one_epoch(model,optimizer,data_loader,device,epoch,print_freq=10)
# update the learning rate
lr_scheduler.step()
# evaluate on the test dataset
evaluate(model,data_loader_test,device=device)
print("That's it!")
解决方法
我只是放了
def collate_fn(batch):
data_list,label_list = [],[]
for _data,_label in batch:
data_list.append(_data)
label_list.append(_label)
return torch.Tensor(data_list),torch.LongTensor(label_list)
在我的代码中，它可以工作。
,更改此aws glacier
到data_loader = torch.utils.data.DataLoader(dataset,batch_size=2,shuffle=True,num_workers=4,collate_fn=utils.collate_fn)
由于您的整理功能使用整理模块
,在 Discussion.pytorch 上有关于本教程的讨论。 https://discuss.pytorch.org/t/object-detection-finetuning-tutorial/52651 您可以在教程中找到：
在 references/detection/ 中，我们有许多辅助函数来简化训练和评估检测模型。在这里，我们将使用references/detection/engine.py、references/detection/utils.py 和references/detection/transforms.py。只需将它们复制到您的文件夹并在此处使用即可。
这个页面有这个文件https://github.com/pytorch/vision/tree/master/references/detection 您还应该安装 pycocotools。