ModuleNotFoundError: No module named ‘podm.metrics‘报错等解决方法

ModuleNotFoundError: No module named 'podm.metrics’报错等解决方法

podm.metrics

在运行时报错：

ModuleNotFoundError: No module named ‘podm.metrics’

安装了podm后还是报错
解决方法：

查看安装位置

查看podm的安装位置，并打开到该位置(ctrl+点击位置)：

pip show podm

新建metrics文件

在该位置下找到podm文件夹，发现其中没有metrics.py文件，故新建该文件

并将一下代码粘贴在文件中：

import sys
from collections import Counter, defaultdict
from enum import Enum
from typing import List, Dict, Any, Tupleimport numpy as npfrom podm import box
from podm.coco import PCOCOObjectDetectionDataset, PCOCOBoundingBox, PCOCOSegmentsclass BoundingBox(box.Box):"""image: image.category: category.xtl: the X top-left coordinate of the bounding box.ytl: the Y top-left coordinate of the bounding box.xbr: the X bottom-right coordinate of the bounding box.ybr: the Y bottom-right coordinate of the bounding box.score: (optional) the confidence of the detected class."""def __init__(self):super(BoundingBox, self).__init__()self.image = Noneself.category = Noneself.score = None  # type: float or None@classmethoddef of_bbox(cls, image, category, xtl: float, ytl: float, xbr: float, ybr: float, score: float = None) \-> 'BoundingBox':bbox = BoundingBox()bbox.xtl = xtlbbox.ytl = ytlbbox.xbr = xbrbbox.ybr = ybrbbox.image = imagebbox.score = scorebbox.category = categoryreturn bboxdef get_bounding_boxes(dataset: PCOCOObjectDetectionDataset, use_name: bool = True) -> List[BoundingBox]:bboxes = []for ann in dataset.annotations:if isinstance(ann, PCOCOBoundingBox):bb = BoundingBox.of_bbox(ann.image_id, ann.category_id, ann.xtl, ann.ytl, ann.xbr, ann.ybr, ann.score)elif isinstance(ann, PCOCOSegments):bb = BoundingBox.of_bbox(ann.image_id, ann.category_id,ann.bbox.xtl, ann.bbox.ytl, ann.bbox.xbr, ann.bbox.ybr, ann.score)else:raise TypeErrorif use_name:bb.image = dataset.get_image(id=ann.image_id).file_namebb.category = dataset.get_category(id=ann.category_id).namebboxes.append(bb)return bboxesclass MethodAveragePrecision(Enum):"""Class representing if the coordinates are relative to theimage size or are absolute values.Developed by: Rafael PadillaLast modification: Apr 28 2018"""AllPointsInterpolation = 1ElevenPointsInterpolation = 2class MetricPerClass:def __init__(self):self.label = Noneself.precision = Noneself.recall = Noneself.ap = Noneself.interpolated_precision = None  # type: None or np.ndarrayself.interpolated_recall = None  # type: None or np.ndarrayself.num_groundtruth = Noneself.num_detection = Noneself.tp = Noneself.fp = None@staticmethoddef mAP(results: Dict[Any, 'MetricPerClass']):return np.average([m.ap for m in results.values() if m.num_groundtruth > 0])def get_pascal_voc_metrics(gold_standard: List[BoundingBox],predictions: List[BoundingBox],iou_threshold: float = 0.5,method: MethodAveragePrecision = MethodAveragePrecision.AllPointsInterpolation) -> Dict[str, MetricPerClass]:"""Get the metrics used by the VOC Pascal 2012 challenge.Args:gold_standard: ground truth bounding boxes;predictions: detected bounding boxes;iou_threshold: IOU threshold indicating which detections will be considered TP or FP (default value = 0.5);method: It can be calculated as the implementation in the official PASCAL VOC toolkit (EveryPointInterpolation),or applying the 11-point interpolation as described in the paper "The PASCAL Visual Object Classes(VOC)Challenge" or AllPointsInterpolation" (ElevenPointInterpolation);Returns:A dictionary containing metrics of each class."""ret = {}  # list containing metrics (precision, recall, average precision) of each class# Get all classescategories = sorted(set(b.category for b in gold_standard + predictions))# Precision x Recall is obtained individually by each class# Loop through by classesfor category in categories:preds = [b for b in predictions if b.category == category]  # type: List[BoundingBox]golds = [b for b in gold_standard if b.category == category]  # type: List[BoundingBox]npos = len(golds)# sort detections by decreasing confidencepreds = sorted(preds, key=lambda b: b.score, reverse=True)tps = np.zeros(len(preds))fps = np.zeros(len(preds))# create dictionary with amount of gts for each imagecounter = Counter([cc.image for cc in golds])for key, val in counter.items():counter[key] = np.zeros(val)# Pre-processing groundtruths of the some imageimage_name2gt = defaultdict(list)for b in golds:image_name2gt[b.image].append(b)# Loop through detectionsfor i in range(len(preds)):# Find ground truth imagegt = image_name2gt[preds[i].image]max_iou = sys.float_info.minmas_idx = -1for j in range(len(gt)):iou = box.intersection_over_union(preds[i], gt[j])if iou > max_iou:max_iou = ioumas_idx = j# Assign detection as true positive/don't care/false positiveif max_iou >= iou_threshold:if counter[preds[i].image][mas_idx] == 0:tps[i] = 1  # count as true positivecounter[preds[i].image][mas_idx] = 1  # flag as already 'seen'else:# - A detected "cat" is overlaped with a GT "cat" with IOU >= IOUThreshold.fps[i] = 1  # count as false positiveelse:fps[i] = 1  # count as false positive# compute precision, recall and average precisioncumulative_fps = np.cumsum(fps)cumulative_tps = np.cumsum(tps)recalls = np.divide(cumulative_tps, npos, out=np.full_like(cumulative_tps, np.nan), where=npos != 0)precisions = np.divide(cumulative_tps, (cumulative_fps + cumulative_tps))# Depending on the method, call the right implementationif method == MethodAveragePrecision.AllPointsInterpolation:ap, mrec, mpre, _ = calculate_all_points_average_precision(recalls, precisions)else:ap, mrec, mpre = calculate_11_points_average_precision(recalls, precisions)# add class result in the dictionary to be returnedr = MetricPerClass()r.label = categoryr.precision = precisionsr.recall = recallsr.ap = apr.interpolated_recall = np.array(mrec)r.interpolated_precision = np.array(mpre)r.tp = np.sum(tps)r.fp = np.sum(fps)r.num_groundtruth = len(golds)r.num_detection = len(preds)ret[category] = rreturn retdef calculate_all_points_average_precision(recall: List[float], precision: List[float]) \-> Tuple[float, List[float], List[float], List[int]]:"""All-point interpolated average precisionReturns:average precisioninterpolated recallinterpolated precisioninterpolated points"""mrec = [0.0] + [e for e in recall] + [1.0]mpre = [0.0] + [e for e in precision] + [0]for i in range(len(mpre) - 1, 0, -1):mpre[i - 1] = max(mpre[i - 1], mpre[i])ii = []for i in range(len(mrec) - 1):if mrec[i + 1] != mrec[i]:ii.append(i + 1)ap = 0for i in ii:ap = ap + np.sum((mrec[i] - mrec[i - 1]) * mpre[i])return ap, mrec[0:len(mpre) - 1], mpre[0:len(mpre) - 1], iidef calculate_11_points_average_precision(recall: List[float], precision: List[float]) -> Tuple[float, List[float], List[float]]:"""11-point interpolated average precision. This is done by segmenting the recalls evenly into 11 parts:{0,0.1,0.2,...,0.9,1}.Args:recall: recall listprecision: precision listReturns:average precision, interpolated recall, interpolated precision"""mrec = [e for e in recall]mpre = [e for e in precision]recall_values = np.linspace(0, 1, 11)recall_values = list(recall_values[::-1])rho_interp = []recall_valid = []# For each recallValues (0, 0.1, 0.2, ... , 1)for r in recall_values:# Obtain all recall values higher or equal than rarg_greater_recalls = np.argwhere(mrec[:] >= r)pmax = 0# If there are recalls above rif arg_greater_recalls.size != 0:pmax = max(mpre[arg_greater_recalls.min():])recall_valid.append(r)rho_interp.append(pmax)# By definition AP = sum(max(precision whose recall is above r))/11ap = sum(rho_interp) / 11# Generating values for the plotrvals = [recall_valid[0]] + [e for e in recall_valid] + [0]pvals = [0] + [e for e in rho_interp] + [0]# rhoInterp = rhoInterp[::-1]cc = []for i in range(len(rvals)):p = (rvals[i], pvals[i - 1])if p not in cc:cc.append(p)p = (rvals[i], pvals[i])if p not in cc:cc.append(p)recall_values = [i[0] for i in reversed(cc)]precision_values = [i[1] for i in reversed(cc)]return ap, recall_values, precision_values

podm.box

报错：

ModuleNotFoundError: No module named ‘podm.coco’

新建coco.py文件，并添加以下内容：

from enum import Enum
from typing import Tupleclass Box:"""0,0 ------> x (width)||  (Left,Top)|      *_________|      |         ||         |y      |_________|(height)            *(Right,Bottom)xtl: the X top-left coordinate of the bounding box.ytl: the Y top-left coordinate of the bounding box.xbr: the X bottom-right coordinate of the bounding box.ybr: the Y bottom-right coordinate of the bounding box."""def __init__(self):self.xtl = None  # type: float or Noneself.ytl = None  # type: float or Noneself.xbr = None  # type: float or Noneself.ybr = None  # type: float or None@classmethoddef of_box(cls, xtl: float, ytl: float, xbr: float, ybr: float) -> 'Box':""":param xtl: the X top-left coordinate of the bounding box.:param ytl: the Y top-left coordinate of the bounding box.:param xbr: the X bottom-right coordinate of the bounding box.:param ybr: the Y bottom-right coordinate of the bounding box."""box = Box()box.xtl = xtlbox.ytl = ytlbox.xbr = xbrbox.ybr = ybrbox.verify()return boxdef set_box(self, box: 'Box'):self.xtl = box.xtlself.ytl = box.ytlself.xbr = box.xbrself.ybr = box.ybrdef verify(self):assert self.xtl <= self.xbr, f'xtl < xbr: xtl:{self.xtl}, xbr:{self.xbr}'assert self.ytl <= self.ybr, f'ytl < ybr: ytl:{self.ytl}, xbr:{self.ybr}'@propertydef segment(self):return [self.xtl, self.ytl, self.xtl, self.ybr, self.xbr, self.ybr, self.xbr, self.ytl]@propertydef width(self) -> float:return self.xbr - self.xtl@propertydef height(self) -> float:return self.ybr - self.ytl@propertydef area(self) -> float:return (self.xbr - self.xtl) * (self.ybr - self.ytl)@propertydef center(self) -> Tuple[float, float]:return (self.xbr + self.xtl) / 2, (self.ybr + self.ytl) / 2def __contains__(self, item):if not type(item) == list and not type(item) == tuple:raise TypeError('Has to be a list or a tuple: %s' % type(item))if len(item) == 2:return self.xtl <= item[0] < self.xbr and self.ytl <= item[1] < self.ybrelse:raise ValueError('Only support a point')def __str__(self):return 'Box[xtl={},ytl={},xbr={},ybr={}]'.format(self.xtl, self.ytl, self.xbr, self.ybr)def __eq__(self, other):if not isinstance(other, Box):return Falsereturn self.xtl == other.xtl and self.ytl == other.ytl and self.xbr == other.xbr and self.ybr == other.ybrdef intersection_over_union(box1: 'Box', box2: 'Box') -> float:"""Intersection Over Union (IOU) is measure based on Jaccard Index that evaluates the overlap betweentwo bounding boxes."""# if boxes dont intersectif not is_intersecting(box1, box2):return 0intersection_area = intersection(box1, box2).areaunion = union_areas(box1, box2, intersection_area=intersection_area)# intersection over unioniou = intersection_area / unionassert iou >= 0, '{} = {} / {}, box1={}, box2={}'.format(iou, intersection, union, box1, box2)return ioudef is_intersecting(box1: 'Box', box2: 'Box') -> bool:if box1.xtl > box2.xbr:return False  # boxA is right of boxBif box2.xtl > box1.xbr:return False  # boxA is left of boxBif box1.ybr < box2.ytl:return False  # boxA is above boxBif box1.ytl > box2.ybr:return False  # boxA is below boxBreturn Truedef union_areas(box1: 'Box', box2: 'Box', intersection_area: float = None) -> float:if intersection_area is None:intersection_area = intersection(box1, box2).areareturn box1.area + box2.area - intersection_areadef union(box1: 'Box', box2: 'Box'):xtl = min(box1.xtl, box2.xtl)ytl = min(box1.ytl, box2.ytl)xbr = max(box1.xbr, box2.xbr)ybr = max(box1.ybr, box2.ybr)return Box.of_box(xtl, ytl, xbr, ybr)def intersection(box1: 'Box', box2: 'Box'):xtl = max(box1.xtl, box2.xtl)ytl = max(box1.ytl, box2.ytl)xbr = min(box1.xbr, box2.xbr)ybr = min(box1.ybr, box2.ybr)return Box.of_box(xtl, ytl, xbr, ybr)class BBFormat(Enum):"""Class representing the format of a bounding box.It can be (X,Y,width,height) => XYWHor (X1,Y1,X2,Y2) => XYX2Y2Developed by: Rafael PadillaLast modification: May 24 2018"""XYWH = 1X1Y1X2Y2 = 2# class BoundingBox(Box):
#     def __init__(self):
#         """Constructor.
#         Args:
#             image: image.
#             category: category.
#             xtl: the X top-left coordinate of the bounding box.
#             ytl: the Y top-left coordinate of the bounding box.
#             xbr: the X bottom-right coordinate of the bounding box.
#             ybr: the Y bottom-right coordinate of the bounding box.
#             score: (optional) the confidence of the detected class.
#         """
#         super(BoundingBox, self).__init__()
#         self.image = None
#         self.category = None
#         self.score = None  # type: float or None
#
#     @classmethod
#     def of_bbox(cls, image, category, xtl: float, ytl: float, xbr: float, ybr: float, score: float = None) \
#             -> 'BoundingBox':
#         bbox = BoundingBox()
#         bbox.xtl = xtl
#         bbox.ytl = ytl
#         bbox.xbr = xbr
#         bbox.ybr = ybr
#         bbox.image = image
#         bbox.score = score
#         bbox.category = category
#         return bbox

podm.coco_decoder

新建coco_decoder.py文件，并添加代码：

import copy
import json
from typing import Dictfrom podm.coco import PCOCOLicense, PCOCOInfo, PCOCOImage, PCOCOCategory, PCOCOBoundingBox, PCOCOSegments, \PCOCOObjectDetectionDatasetdef parse_infon(obj: Dict) -> PCOCOInfo:info = PCOCOInfo()info.contributor = obj['contributor']info.description = obj['description']info.url = obj['url']info.date_created = obj['date_created']info.version = obj['version']info.year = obj['year']return infodef parse_license(obj: Dict) -> PCOCOLicense:lic = PCOCOLicense()lic.id = obj['id']lic.name = obj['name']lic.url = obj['url']return licdef parse_image(obj: Dict) -> PCOCOImage:img = PCOCOImage()img.id = obj['id']img.height = obj['height']img.width = obj['width']img.file_name = obj['file_name']img.flickr_url = obj['flickr_url']img.coco_url = obj['coco_url']img.date_captured = obj['date_captured']img.license = obj['license']return imgdef parse_bounding_box(obj: Dict) -> PCOCOBoundingBox:ann = PCOCOBoundingBox()ann.id = obj['id']ann.category_id = obj['category_id']ann.image_id = obj['image_id']ann.xtl = obj['bbox'][0]ann.ytl = obj['bbox'][1]ann.xbr = ann.xtl + obj['bbox'][2]ann.ybr = ann.ytl + obj['bbox'][3]if 'contributor' in obj:ann.contributor = obj['contributor']if 'score' in obj:ann.score = obj['score']if 'attributes' in obj:ann.attributes = obj['attributes']return anndef parse_segments(obj: Dict) -> PCOCOSegments:ann = PCOCOSegments()ann.id = obj['id']ann.category_id = obj['category_id']ann.image_id = obj['image_id']ann.iscrowd = obj['iscrowd']ann.segmentation = obj['segmentation']if 'score' in obj:ann.score = obj['score']if 'contributor' in obj:ann.contributor = obj['contributor']if 'attributes' in obj:ann.attributes = obj['attributes']return anndef parse_category(obj: Dict) -> PCOCOCategory:cat = PCOCOCategory()cat.id = obj['id']cat.name = obj['name']cat.supercategory = obj['supercategory']return catdef parse_object_detection_dataset(coco_obj: Dict) -> PCOCOObjectDetectionDataset:dataset = PCOCOObjectDetectionDataset()dataset.info = parse_infon(coco_obj['info'])for lic_obj in coco_obj['licenses']:lic = parse_license(lic_obj)dataset.licenses.append(lic)for img_obj in coco_obj['images']:img = parse_image(img_obj)dataset.images.append(img)for ann_obj in coco_obj['annotations']:if 'segmentation' in ann_obj and len(ann_obj['segmentation']) > 0:ann = parse_segments(ann_obj)else:ann = parse_bounding_box(ann_obj)dataset.add_annotation(ann)for cat_obj in coco_obj['categories']:cat = parse_category(cat_obj)dataset.categories.append(cat)return datasetdef load_true_object_detection_dataset(fp, **kwargs) -> PCOCOObjectDetectionDataset:coco_obj = json.load(fp, **kwargs)return parse_object_detection_dataset(coco_obj)def load_pred_object_detection_dataset(fp, dataset: PCOCOObjectDetectionDataset, **kwargs) \-> PCOCOObjectDetectionDataset:new_dataset = PCOCOObjectDetectionDataset()new_dataset.info = copy.deepcopy(dataset.info)new_dataset.licenses = copy.deepcopy(dataset.licenses)new_dataset.images = copy.deepcopy(dataset.images)new_dataset.categories = copy.deepcopy(dataset.categories)# check annotationcoco_obj = json.load(fp, **kwargs)annotations = []for obj in coco_obj:ann = parse_bounding_box(obj)if new_dataset.get_image(id=ann.image_id) is None:print('%s: Cannot find image' % ann.image_id)if new_dataset.get_category(id=ann.category_id) is None:print('%s: Cannot find category' % ann.category_id)annotations.append(ann)new_dataset.annotations = annotationsreturn new_dataset

podm.coco_encoder

新建coco_encoder.py文件，并添加以下代码：

import json
from typing import Union, TextIO, Dict, Listfrom podm.coco import PCOCOImage, PCOCOLicense, PCOCOInfo, \PCOCOCategory, PCOCOBoundingBox, \PCOCOSegments, PCOCOObjectDetectionDatasetPCOCO_OBJ = Union[PCOCOImage, PCOCOLicense, PCOCOInfo,PCOCOCategory,PCOCOObjectDetectionDataset,List[PCOCOBoundingBox],
]class PCOCOJSONEncoder(json.JSONEncoder):"""Extensible BioC JSON encoder for BioC data structures."""def default(self, o):# print('xxxxxxxxxxxxxxxxxxxx')# print(type(o))# print(isinstance(o, PCOCOObjectDetectionDataset))# print(repr(o.__class__), repr(PCOCOObjectDetectionResult))if isinstance(o, PCOCOImage):return {"width": o.width,"height": o.height,"flickr_url": o.flickr_url,"coco_url": o.coco_url,"file_name": o.file_name,"date_captured": o.date_captured,"license": o.license,"id": o.id,}if isinstance(o, PCOCOLicense):return {"id": o.id,"name": o.name,"url": o.url,}if isinstance(o, PCOCOInfo):return {"year": o.year,"version": o.version,"description": o.description,"contributor": o.contributor,"url": o.url,"date_created": o.date_created,}if isinstance(o, PCOCOCategory):return {"id": o.id,"name": o.name,"supercategory": o.supercategory,}if isinstance(o, PCOCOBoundingBox):return {"id": o.id,"image_id": o.image_id,"category_id": o.category_id,"bbox": [o.xtl, o.ytl, o.width, o.height],"score": o.score,"contributor": o.contributor,"attributes": json.dumps(o.attributes)}if isinstance(o, PCOCOSegments):bb = o.bboxreturn {"id": o.id,"image_id": o.image_id,"category_id": o.category_id,"segmentation": o.segmentation,"bbox": [bb.xtl, bb.ytl, bb.width, bb.height],"area": bb.area,"iscrowd": o.iscrowd,"score": o.score,"contributor": o.contributor,"attributes": json.dumps(o.attributes)}if isinstance(o, PCOCOObjectDetectionDataset):return {"info": self.default(o.info),'images': [self.default(img) for img in o.images],"licenses": [self.default(l) for l in o.licenses],'annotations': [self.default(ann) for ann in o.annotations],'categories': [self.default(cat) for cat in o.categories],}# Let the base class default method raise the TypeErrorreturn json.JSONEncoder.default(self, o)def toJSON(o) -> Dict:"""Convert a pcoco obj to a Python `dict`"""return PCOCOJSONEncoder().default(o)def dumps(obj: PCOCO_OBJ, **kwargs) -> str:"""Serialize a BioC ``obj`` to a JSON formatted ``str``. kwargs are passed to json."""return json.dumps(obj, cls=PCOCOJSONEncoder, indent=2, **kwargs)def dump(obj: PCOCO_OBJ, fp: TextIO, **kwargs):"""Serialize ``obj`` as a JSON formatted stream to ``fp``(a ``.write()``-supporting file-like object). kwargs are passed to json."""return json.dump(obj, fp, cls=PCOCOJSONEncoder, indent=2, **kwargs)```## podm.coco新建`coco.py`文件，并添加：```pythonimport copy
from abc import ABC
from typing import List, Tuple, Set, Collection
from datetime import date, datetime
from shapely.geometry import Polygon, Point
from podm import boxclass PCOCOInfo:def __init__(self):self.year = date.today().year  # type:intself.version = ''  # type: strself.description = ''  # type: strself.contributor = ''  # type: strself.url = ''  # type: strself.date_created = datetime.now().strftime('%m/%d/%Y')  # type:strclass PCOCOAnnotation(ABC):def __init__(self):self.id = None  # type:int or Noneself.image_id = None  # type:int or Noneself.score = None  # type:float or Noneself.contributor = ''  # type: strself.attributes = {}  # type: dictclass PCOCOImage:def __init__(self):self.id = None  # type:int or Noneself.width = 0  # type:intself.height = 0  # type:intself.file_name = ''  # type:strself.license = None  # type:int or Noneself.flickr_url = ''  # type:strself.coco_url = ''  # type:strself.date_captured = datetime.now().strftime('%m/%d/%Y')  # type:strclass PCOCOLicense:def __init__(self):self.id = None  # type:int or Noneself.name = ''  # type:strself.url = ''  # type:strclass PCOCOCategory:def __init__(self):self.id = None  # type:int or Noneself.name = ''  # type:strself.supercategory = ''  # type:strclass PCOCODataset(ABC):def __init__(self):self.info = PCOCOInfo()  # type: PCOCOInfo or Noneself.images = []  # type: List[PCOCOImage]self.licenses = []  # type: List[PCOCOLicense]def add_license(self, license: PCOCOLicense):for lic in self.licenses:if lic.id == license.id or lic.name == license.name:raise KeyError('%s: License exists' % lic.id)self.licenses.append(license)def add_image(self, image: PCOCOImage):for img in self.images:if img.id == image.id or img.file_name == image.file_name:raise KeyError('%s: Image exists' % img.id)self.images.append(image)def get_image(self, id: int = None, file_name: str = None, default=None) -> PCOCOImage:if id is None and file_name is None:raise KeyError('%s %s: Cannot set both to None' % (id, file_name))if id is not None and file_name is not None:raise KeyError('%s %s: Cannot set both' % (id, file_name))imgs = self.imagesif id is not None:imgs = [img for img in imgs if img.id == id]if len(imgs) == 0:return defaultelif len(imgs) == 1:return next(iter(imgs))else:raise KeyError('%s: more than one image with the same id' % id)if file_name is not None:imgs = [img for img in imgs if img.file_name == file_name]if len(imgs) == 0:return defaultelif len(imgs) == 1:return next(iter(imgs))else:raise KeyError('%s: more than one image with the same name' % file_name)raise Exception('Should not be here')def get_images(self, ids: Collection[int] = None) -> List[PCOCOImage]:"""Load anns with the specified ids.:param ids: integer ids specifying img:return: imgs: loaded img objects"""return [img for img in self.images if img.id in ids]##############################################################################
# object detection
##############################################################################class PCOCOBoundingBox(PCOCOAnnotation, box.Box):def __init__(self):super(PCOCOBoundingBox, self).__init__()self.category_id = None  # type:int or Noneclass PCOCOSegments(PCOCOAnnotation):def __init__(self):super(PCOCOSegments, self).__init__()self.category_id = None  # type:int or Noneself.segmentation = []  # type: List[List[float]]self.iscrowd = False  # type:booldef add_box(self, box: box.Box):self.add_segmentation(box.segment)def add_segmentation(self, segmentation: List[float]):self.segmentation.append(segmentation)def __contains__(self, item):if not type(item) == list and not type(item) == tuple:raise TypeError('Has to be a list or a tuple: %s' % type(item))if len(item) == 2:point = Point(item[0], item[1])for p in self.polygons:if p.contains(point):return Truereturn Falseelse:raise ValueError('Only support a point')@propertydef polygons(self) -> List[Polygon]:return [Polygon([(seg[i], seg[i+1]) for i in range(0, len(seg), 2)]) for seg in self.segmentation]@propertydef bbox(self) -> 'box.Box' or None:if len(self.segmentation) == 0:return Noneelse:b = self.box_polygon(self.segmentation[0])for polygon in self.segmentation[1:]:b = box.union(b, self.box_polygon(polygon))return b@classmethoddef box_polygon(cls, polygon: List[float]) -> 'box.Box':xtl = min(polygon[i] for i in range(0, len(polygon), 2))ytl = min(polygon[i] for i in range(1, len(polygon), 2))xbr = max(polygon[i] for i in range(0, len(polygon), 2))ybr = max(polygon[i] for i in range(1, len(polygon), 2))return box.Box.of_box(xtl, ytl, xbr, ybr)class PCOCOImageCaptioning(PCOCOAnnotation):def __init__(self):super(PCOCOImageCaptioning, self).__init__()self.caption = None  # type:str or Noneclass PCOCOObjectDetectionDataset(PCOCODataset):def __init__(self):super(PCOCOObjectDetectionDataset, self).__init__()self.annotations = []  # type: List[PCOCOBoundingBox or PCOCOSegments]self.categories = []  # type: List[PCOCOCategory]def add_annotation(self, annotation: 'PCOCOBoundingBox' or 'PCOCOSegments'):for ann in self.annotations:if ann.id == annotation.id:raise KeyError('%s: Annotation exists' % ann.id)self.annotations.append(annotation)def add_category(self, category: PCOCOCategory):for cat in self.categories:if cat.id == category.id or cat.name == category.name:raise KeyError('%s: Category exists' % cat.id)self.categories.append(category)def get_max_category_id(self):return max(cat.id for cat in self.categories)def get_category(self, id: int = None, name: str = None, default=None) -> PCOCOCategory:if id is None and name is None:raise KeyError('%s %s: Cannot set both to None' % (id, name))if id is not None and name is not None:raise KeyError('%s %s: Cannot set both' % (id, name))cats = self.categoriesif id is not None:cats = [cat for cat in cats if cat.id == id]if len(cats) == 0:return defaultelif len(cats) == 1:return next(iter(cats))else:raise KeyError('%s: more than one category with the same id' % id)if name is not None:cats = [cat for cat in cats if cat.name == name]if len(cats) == 0:return defaultelif len(cats) == 1:return next(iter(cats))else:raise KeyError('%s: more than one category with the same name' % name)raise Exception('Should not be here')def get_annotation(self, id: int, default=None) -> PCOCOAnnotation:anns = [ann for ann in self.annotations if ann.id == id]if len(anns) == 0:return defaultelif len(anns) == 1:return next(iter(anns))else:raise KeyError('%s: more than one annotation' % id)def get_new_dataset(self, annotations: Collection[PCOCOBoundingBox or PCOCOSegments]):new_dataset = PCOCOObjectDetectionDataset()new_dataset.info = copy.deepcopy(self.info)new_dataset.licenses = copy.deepcopy(self.licenses)new_dataset.images = copy.deepcopy(self.images)new_dataset.categories = copy.deepcopy(self.categories)for ann in annotations:new_dataset.add_annotation(ann)return new_datasetdef get_category_ids(self, category_names: Collection[str] = None,supercategory_names: Collection[str] = None) -> Collection[int]:"""filtering parameters. default skips that filter.:param category_names: get cats for given cat names:param supercategory_names: get cats for given supercategory names:return: integer array of cat ids"""itr = iter(self.categories)if category_names is not None:itr = filter(lambda x: x.name in category_names, itr)if supercategory_names is not None:itr = filter(lambda x: x.supercategory in supercategory_names, itr)return [cat.id for cat in itr]def get_annotation_ids(self, image_ids: Collection[int] = None,category_ids: Collection[int] = None,area_range: Tuple[float, float] = None) -> Collection[int]:"""Get ann ids that satisfy given filter conditions. default skips that filter:param image_ids: get anns for given imgs:param category_ids: get anns for given cats:param area_range: get anns for given area range (e.g. [0 inf]):return: integer array of ann ids"""# image_ids = convert_array_argument(image_ids)# category_ids = convert_array_argument(category_ids)# area_range = convert_array_argument(area_range)itr = iter(self.annotations)if image_ids is not None:itr = filter(lambda x: x.image_id in image_ids, itr)if category_ids is not None:itr = filter(lambda x: x.category_id in category_ids, itr)if area_range is not None:itr = filter(lambda x: area_range[0] <= x.area <= area_range[1], itr)return [ann.id for ann in itr]def get_image_ids(self, category_ids: Collection[int] = None) -> Collection[int]:"""Get img ids that satisfy given filter conditions.:param category_ids: get imgs with all given cats:return: ids: integer array of img ids"""ids = set(img.id for img in self.images)for i, cat_id in enumerate(category_ids):if i == 0 and len(ids) == 0:ids = set(ann.image_id for ann in self.annotations if ann.category_id == cat_id)else:ids &= set(ann.image_id for ann in self.annotations if ann.category_id == cat_id)return list(ids)def get_annotations(self, ids: Collection[int] = None) -> Collection[PCOCOAnnotation]:"""Load anns with the specified ids.:param ids: integer ids specifying anns:return: anns: loaded ann objects"""return [ann for ann in self.annotations if ann.id in ids]def get_categories(self, ids: Collection[int] = None) -> Collection[PCOCOCategory]:"""Load cats with the specified ids.:param ids: integer ids specifying cats:return: cats: loaded cat objects"""return [cat for cat in self.categories if cat.id in ids]

podm.coco2labelme

新建coco2labelme.py文件，并添加代码：

from podm.coco import PCOCOObjectDetectionDataset, PCOCOBoundingBox, PCOCOSegmentsdef coco2labelme(cocodataset: PCOCOObjectDetectionDataset):objs = []for img in cocodataset.images:obj = {"version": "5.0.1","flags": {},"imagePath": img.file_name,"imageData": None,"imageHeight": img.height,"imageWidth": img.width,"shapes": []}for annid in cocodataset.get_annotation_ids(image_ids=[img.id]):ann = cocodataset.get_annotation(annid)if isinstance(ann, PCOCOBoundingBox):shape = {"label": ann.attributes['ID'],"points": [[ann.xtl, ann.ytl], [ann.xbr, ann.ybr]],"group_id": None,"shape_type": "rectangle","flags": {}}elif isinstance(ann, PCOCOSegments):shape = {"label": ann.attributes['ID'],"points": [[ann.segmentation[0][i], ann.segmentation[0][i+1]]for i in range(0, len(ann.segmentation[0]), 2)],"group_id": None,"shape_type": "polygon","flags": {}}else:raise TypeErrorobj['shapes'].append(shape)objs.append(obj)return objs

podm.pascal2coco

新建pascal2coco.py文件，并添加以下代码：

"""
Convert from a PASCAL VOC zip file to a COCO file.Usage:pascal2coco gold --gold=<file> --output-gold=<file>pascal2coco pred --gold=<file> --pred=<file> --output-gold=<file> --output-pred=<file>Options:--gold=<file>           PASCAL VOC groundtruths zip file--pred=<file>           PASCAL VOC predictions zip file--output-gold=<file>    Groundtruths JSON file--output-pred=<file>    Predictions JSON file
"""
import json
import zipfile
import io
import warningsimport docopt
import tqdm
import pandas as pd
from podm import coco_encoder
from podm.box import BBFormat, Box
from podm.coco import PCOCOObjectDetectionDataset, PCOCOImage, PCOCOCategory, PCOCOBoundingBoxdef convert_pascal_to_df(src):rows = []with zipfile.ZipFile(src, 'r') as myzip:namelist = myzip.namelist()for name in tqdm.tqdm(namelist):if not name.endswith('.txt'):continuewith myzip.open(name, 'r') as fp:name = name[name.find('/') + 1:]items_file = io.TextIOWrapper(fp)for line in items_file:toks = line.strip().split(' ')if len(toks) == 5:row = {'name': name,'label': toks[0],'xtl': int(toks[1]),'ytl': int(toks[2]),'xbr': int(toks[3]),'ybr': int(toks[4])}elif len(toks) == 6:row = {'name': name,'label': toks[0],'score': float(toks[1]),'xtl': int(toks[2]),'ytl': int(toks[3]),'xbr': int(toks[4]),'ybr': int(toks[5])}else:raise ValueErrorrows.append(row)return pd.DataFrame(rows)class PascalVoc2COCO:def __init__(self, format: BBFormat = BBFormat.X1Y1X2Y2):self.format = formatdef convert_gold(self, src) -> PCOCOObjectDetectionDataset:df = convert_pascal_to_df(src)dataset = PCOCOObjectDetectionDataset()# add imagefor i, name in enumerate(df['name'].unique()):img = PCOCOImage()img.id = iimg.file_name = namedataset.add_image(img)# add categoryfor i, label in enumerate(df['label'].unique()):cat = PCOCOCategory()cat.id = icat.name = labeldataset.add_category(cat)# add annotationfor i, row in tqdm.tqdm(df.iterrows(), total=len(df)):box = Box.of_box(row['xtl'], row['ytl'], row['xbr'], row['ybr'])if self.format == BBFormat.XYWH:box.xbr += box.xtlbox.ybr += box.ytlann = PCOCOBoundingBox()ann.image_id = dataset.get_image(file_name=row['name']).idann.id = iann.category_id = dataset.get_category(name=row['label']).idann.set_box(box)dataset.add_annotation(ann)return datasetdef convert_gold_file(self, src, dest):dataset = self.convert_gold(src)with open(dest, 'w') as fp:coco_encoder.dump(dataset, fp)def convert_gold_pred(self, src_gold, src_pred):gold_dataset = self.convert_gold(src_gold)df = convert_pascal_to_df(src_pred)# check catsubrows = []for i, row in tqdm.tqdm(df.iterrows(), total=len(df)):if gold_dataset.get_category(name=row['label']) is None:warnings.warn('%s: Category does not exist' % row['label'])continueif gold_dataset.get_image(file_name=row['name']) is None:warnings.warn('%s: Image does not exist' % row['name'])continuesubrows.append(row)if len(subrows) < len(df):warnings.warn('Remove %s rows' % (len(df) - len(subrows)))annotations = []for i, row in tqdm.tqdm(enumerate(subrows), total=len(subrows)):box = Box.of_box(row['xtl'], row['ytl'], row['xbr'], row['ybr'])if self.format == BBFormat.XYWH:box.xbr += box.xtlbox.ybr += box.ytlann = PCOCOBoundingBox()ann.image_id = gold_dataset.get_image(file_name=row['name']).idann.id = iann.category_id = gold_dataset.get_category(name=row['label']).idann.score = row['score']ann.set_box(box)annotations.append(ann)pred_dataset = gold_dataset.get_new_dataset(annotations)return gold_dataset, pred_datasetdef convert_gold_pred_file(self, src_gold, src_pred, dest_gold, dest_pred):gold_dataset, pred_dataset = self.convert_gold_pred(src_gold, src_pred)with open(dest_gold, 'w') as fp:coco_encoder.dump(gold_dataset, fp)with open(dest_pred, 'w') as fp:json.dump(pred_dataset.annotations, fp, cls=coco_encoder.PCOCOJSONEncoder, indent=2)def main():argv = docopt.docopt(__doc__)converter = PascalVoc2COCO(BBFormat.X1Y1X2Y2)if argv['gold']:converter.convert_gold_file(argv['--gold'], argv['--output-gold'])if argv['pred']:converter.convert_gold_pred_file(argv['--gold'], argv['--pred'], argv['--output-gold'], argv['--output-pred'])if __name__ == '__main__':main()

最终文件夹内容

最终文件夹中内容如下：