642 lines
27 KiB
Python
642 lines
27 KiB
Python
# Plotting utils
|
||
|
||
import glob
|
||
import math
|
||
import os,sys
|
||
import random
|
||
from copy import copy
|
||
from pathlib import Path
|
||
|
||
import cv2
|
||
import matplotlib
|
||
import matplotlib.pyplot as plt
|
||
import numpy as np
|
||
import pandas as pd
|
||
import seaborn as sns
|
||
import torch
|
||
import yaml
|
||
from PIL import Image, ImageDraw, ImageFont
|
||
from scipy.signal import butter, filtfilt,savgol_filter
|
||
|
||
from utils.general import xywh2xyxy, xyxy2xywh
|
||
from utils.metrics import fitness
|
||
|
||
# Settings
|
||
matplotlib.rc('font', **{'size': 11})
|
||
#matplotlib.use('Agg') # for writing to files only
|
||
|
||
def smooth_outline(contours,p1,p2):
|
||
arcontours=np.array(contours)
|
||
coors_x=arcontours[0,:,0,0]
|
||
coors_y=arcontours[0,:,0,1]
|
||
coors_x_smooth= savgol_filter(coors_x,p1,p2)
|
||
coors_y_smooth= savgol_filter(coors_y,p1,p2)
|
||
arcontours[0,:,0,0] = coors_x_smooth
|
||
arcontours[0,:,0,1] = coors_y_smooth
|
||
return arcontours
|
||
def smooth_outline_auto(contours):
|
||
cnt = len(contours[0])
|
||
p1 = int(cnt/12)*2+1
|
||
p2 =3
|
||
if p1<p2: p2 = p1-1
|
||
return smooth_outline(contours,p1,p2)
|
||
|
||
def get_websource(txtfile):
|
||
with open(txtfile,'r') as fp:
|
||
lines = fp.readlines()
|
||
webs=[];ports=[];streamNames=[]
|
||
for line in lines:
|
||
try:
|
||
sps = line.strip().split(' ')
|
||
webs.append(sps[0])
|
||
#rtmp://liveplay.yunhengzhizao.cn/live/demo_HD5M
|
||
if 'rtmp' in sps[0]:
|
||
name = sps[0].split('/')[4].split('_')[0]
|
||
else:
|
||
name = sps[0][-3:]
|
||
ports.append(sps[1])
|
||
streamNames.append(name)
|
||
|
||
except:
|
||
|
||
print('####format error : %s , in file:%s#####'%(line,txtfile))
|
||
assert len(webs)>0
|
||
return webs,ports,streamNames
|
||
|
||
|
||
def get_label_array( color=None, label=None,outfontsize=None,fontpath="conf/platech.ttf"):
|
||
|
||
# Plots one bounding box on image 'im' using PIL
|
||
fontsize = outfontsize
|
||
font = ImageFont.truetype(fontpath, fontsize,encoding='utf-8')
|
||
|
||
txt_width, txt_height = font.getsize(label)
|
||
im = np.zeros((txt_height,txt_width,3),dtype=np.uint8)
|
||
im = Image.fromarray(im)
|
||
draw = ImageDraw.Draw(im)
|
||
draw.rectangle([0, 0 , txt_width, txt_height ], fill=tuple(color))
|
||
draw.text(( 0 , -3 ), label, fill=(255, 255, 255), font=font)
|
||
im_array = np.asarray(im)
|
||
|
||
if outfontsize:
|
||
scaley = outfontsize / txt_height
|
||
im_array= cv2.resize(im_array,(0,0),fx = scaley ,fy =scaley)
|
||
return im_array
|
||
def get_label_arrays(labelnames,colors,outfontsize=40,fontpath="conf/platech.ttf"):
|
||
label_arraylist = []
|
||
if len(labelnames) > len(colors):
|
||
print('#####labelnames cnt > colors cnt#####')
|
||
for ii,labelname in enumerate(labelnames):
|
||
|
||
color = colors[ii%20]
|
||
label_arraylist.append(get_label_array(color=color,label=labelname,outfontsize=outfontsize,fontpath=fontpath))
|
||
|
||
return label_arraylist
|
||
def color_list():
|
||
# Return first 10 plt colors as (r,g,b) https://stackoverflow.com/questions/51350872/python-from-color-name-to-rgb
|
||
def hex2rgb(h):
|
||
return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
|
||
|
||
return [hex2rgb(h) for h in matplotlib.colors.TABLEAU_COLORS.values()] # or BASE_ (8), CSS4_ (148), XKCD_ (949)
|
||
|
||
|
||
def hist2d(x, y, n=100):
|
||
# 2d histogram used in labels.png and evolve.png
|
||
xedges, yedges = np.linspace(x.min(), x.max(), n), np.linspace(y.min(), y.max(), n)
|
||
hist, xedges, yedges = np.histogram2d(x, y, (xedges, yedges))
|
||
xidx = np.clip(np.digitize(x, xedges) - 1, 0, hist.shape[0] - 1)
|
||
yidx = np.clip(np.digitize(y, yedges) - 1, 0, hist.shape[1] - 1)
|
||
return np.log(hist[xidx, yidx])
|
||
|
||
|
||
def butter_lowpass_filtfilt(data, cutoff=1500, fs=50000, order=5):
|
||
# https://stackoverflow.com/questions/28536191/how-to-filter-smooth-with-scipy-numpy
|
||
def butter_lowpass(cutoff, fs, order):
|
||
nyq = 0.5 * fs
|
||
normal_cutoff = cutoff / nyq
|
||
return butter(order, normal_cutoff, btype='low', analog=False)
|
||
|
||
b, a = butter_lowpass(cutoff, fs, order=order)
|
||
return filtfilt(b, a, data) # forward-backward filter
|
||
|
||
|
||
'''image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
|
||
pil_image = Image.fromarray(image)
|
||
draw = ImageDraw.Draw(pil_image)
|
||
font = ImageFont.truetype('./font/platech.ttf', 40, encoding='utf-8')
|
||
for info in infos:
|
||
detect = info['bndbox']
|
||
text = ','.join(list(info['attributes'].values()))
|
||
temp = -50
|
||
if info['name'] == 'vehicle':
|
||
temp = 20
|
||
draw.text((detect[0], detect[1] + temp), text, (0, 255, 255), font=font)
|
||
if 'scores' in info:
|
||
draw.text((detect[0], detect[3]), info['scores'], (0, 255, 0), font=font)
|
||
if 'pscore' in info:
|
||
draw.text((detect[2], detect[3]), str(round(info['pscore'],3)), (0, 255, 0), font=font)
|
||
image = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
|
||
for info in infos:
|
||
detect = info['bndbox']
|
||
cv2.rectangle(image, (detect[0], detect[1]), (detect[2], detect[3]), (0, 255, 0), 1, cv2.LINE_AA)
|
||
return image'''
|
||
|
||
'''def plot_one_box_PIL(x, im, color=None, label=None, line_thickness=3):
|
||
# Plots one bounding box on image 'im' using OpenCV
|
||
assert im.data.contiguous, 'Image not contiguous. Apply np.ascontiguousarray(im) to plot_on_box() input image.'
|
||
tl = line_thickness or round(0.002 * (im.shape[0] + im.shape[1]) / 2) + 1 # line/font thickness
|
||
color = color or [random.randint(0, 255) for _ in range(3)]
|
||
c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
|
||
|
||
|
||
|
||
cv2.rectangle(im, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
|
||
|
||
|
||
if label:
|
||
tf = max(tl - 1, 1) # font thickness
|
||
t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
|
||
c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
|
||
cv2.rectangle(im, c1, c2, color, -1, cv2.LINE_AA) # filled
|
||
|
||
im = Image.fromarray(im)
|
||
draw = ImageDraw.Draw(im)
|
||
font = ImageFont.truetype('./font/platech.ttf', t_size, encoding='utf-8')
|
||
draw.text((c1[0], c1[1] - 2), label, (0, 255, 0), font=font)
|
||
|
||
#cv2.putText(im, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
|
||
return np.array(im) '''
|
||
|
||
def plot_one_box(x, im, color=None, label=None, line_thickness=3):
|
||
# Plots one bounding box on image 'im' using OpenCV
|
||
assert im.data.contiguous, 'Image not contiguous. Apply np.ascontiguousarray(im) to plot_on_box() input image.'
|
||
tl = line_thickness or round(0.002 * (im.shape[0] + im.shape[1]) / 2) + 1 # line/font thickness
|
||
color = color or [random.randint(0, 255) for _ in range(3)]
|
||
c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
|
||
cv2.rectangle(im, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
|
||
|
||
if label:
|
||
tf = max(tl - 1, 1) # font thickness
|
||
t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
|
||
c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
|
||
cv2.rectangle(im, c1, c2, color, -1, cv2.LINE_AA) # filled
|
||
cv2.putText(im, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
|
||
|
||
|
||
def plot_one_box_PIL(box, im, color=None, label=None, line_thickness=None):
|
||
# Plots one bounding box on image 'im' using PIL
|
||
|
||
im = Image.fromarray(im)
|
||
draw = ImageDraw.Draw(im)
|
||
line_thickness = line_thickness or max(int(min(im.size) / 200), 2)
|
||
draw.rectangle(box, width=line_thickness, outline=tuple(color)) # plot
|
||
|
||
if label:
|
||
fontsize = max(round(max(im.size) / 40), 12)
|
||
font = ImageFont.truetype("../AIlib2/conf/platech.ttf", fontsize,encoding='utf-8')
|
||
txt_width, txt_height = font.getsize(label)
|
||
draw.rectangle([box[0], box[1] - txt_height + 4, box[0] + txt_width, box[1]], fill=tuple(color))
|
||
draw.text((box[0], box[1] - txt_height + 1), label, fill=(255, 255, 255), font=font)
|
||
im_array = np.asarray(im)
|
||
|
||
return np.asarray(im)
|
||
|
||
def draw_painting_joint(box,img,label_array,score=0.5,color=None,font={ 'line_thickness':None,'boxLine_thickness':None, 'fontSize':None},socre_location="leftTop"):
|
||
#如果box[0]不是list or 元组，则box是[ (x0,y0),(x1,y1),(x2,y2),(x3,y3)]四点格式
|
||
if isinstance(box[0], (list, tuple,np.ndarray ) ):
|
||
###先把中文类别字体赋值到img中
|
||
lh, lw, lc = label_array.shape
|
||
imh, imw, imc = img.shape
|
||
if socre_location=='leftTop':
|
||
x0 , y1 = box[0][0],box[0][1]
|
||
elif socre_location=='leftBottom':
|
||
x0,y1=box[3][0],box[3][1]
|
||
else:
|
||
print('plot.py line217 ,label_location:%s not implemented '%( socre_location ))
|
||
sys.exit(0)
|
||
|
||
x1 , y0 = x0 + lw , y1 - lh
|
||
if y0<0:y0=0;y1=y0+lh
|
||
if y1>imh: y1=imh;y0=y1-lh
|
||
if x0<0:x0=0;x1=x0+lw
|
||
if x1>imw:x1=imw;x0=x1-lw
|
||
img[y0:y1,x0:x1,:] = label_array
|
||
pts_cls=[(x0,y0),(x1,y1) ]
|
||
|
||
#把四边形的框画上
|
||
box_tl= font['boxLine_thickness'] or round(0.002 * (imh + imw) / 2) + 1
|
||
cv2.polylines(img, [box], True,color , box_tl)
|
||
|
||
####把英文字符score画到类别旁边
|
||
tl = font['line_thickness'] or round(0.002*(imh+imw)/2)+1#line/font thickness
|
||
label = ' %.2f'%(score)
|
||
tf = max(tl , 1) # font thickness
|
||
fontScale = font['fontSize'] or tl * 0.33
|
||
t_size = cv2.getTextSize(label, 0, fontScale=fontScale , thickness=tf)[0]
|
||
|
||
|
||
#if socre_location=='leftTop':
|
||
p1,p2= (pts_cls[1][0], pts_cls[0][1]),(pts_cls[1][0]+t_size[0],pts_cls[1][1])
|
||
cv2.rectangle(img, p1 , p2, color, -1, cv2.LINE_AA)
|
||
p3 = pts_cls[1][0],pts_cls[1][1]-(lh-t_size[1])//2
|
||
|
||
cv2.putText(img, label,p3, 0, fontScale, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
|
||
return img
|
||
else:####两点格式[x0,y0,x1,y1]
|
||
try:
|
||
box = [int(xx.cpu()) for xx in box]
|
||
except:
|
||
box=[ int(x) for x in box]
|
||
###先把中文类别字体赋值到img中
|
||
lh, lw, lc = label_array.shape
|
||
imh, imw, imc = img.shape
|
||
if socre_location=='leftTop':
|
||
x0 , y1 = box[0:2]
|
||
elif socre_location=='leftBottom':
|
||
x0,y1=box[0],box[3]
|
||
else:
|
||
print('plot.py line217 ,socre_location:%s not implemented '%( socre_location ))
|
||
sys.exit(0)
|
||
x1 , y0 = x0 + lw , y1 - lh
|
||
if y0<0:y0=0;y1=y0+lh
|
||
if y1>imh: y1=imh;y0=y1-lh
|
||
if x0<0:x0=0;x1=x0+lw
|
||
if x1>imw:x1=imw;x0=x1-lw
|
||
img[y0:y1,x0:x1,:] = label_array
|
||
|
||
|
||
|
||
###把矩形框画上，指定颜色和线宽
|
||
tl = font['line_thickness'] or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1 # line/font thickness
|
||
box_tl= font['boxLine_thickness'] or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1
|
||
c1, c2 = (int(box[0]), int(box[1])), (int(box[2]), int(box[3]))
|
||
cv2.rectangle(img, c1, c2, color, thickness=box_tl, lineType=cv2.LINE_AA)
|
||
|
||
###把英文字符score画到类别旁边
|
||
label = ' %.2f'%(score)
|
||
tf = max(tl , 1) # font thickness
|
||
fontScale = font['fontSize'] or tl * 0.33
|
||
t_size = cv2.getTextSize(label, 0, fontScale=fontScale , thickness=tf)[0]
|
||
|
||
if socre_location=='leftTop':
|
||
c2 = c1[0]+ lw + t_size[0], c1[1] - lh
|
||
cv2.rectangle(img, (int(box[0])+lw,int(box[1])) , c2, color, -1, cv2.LINE_AA) # filled
|
||
cv2.putText(img, label, (c1[0]+lw, c1[1] - (lh-t_size[1])//2 ), 0, fontScale, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
|
||
elif socre_location=='leftBottom':
|
||
c2 = box[0]+ lw + t_size[0], box[3] - lh
|
||
cv2.rectangle(img, (int(box[0])+lw,int(box[3])) , c2, color, -1, cv2.LINE_AA) # filled
|
||
cv2.putText(img, label, ( box[0] + lw, box[3] - (lh-t_size[1])//2 ), 0, fontScale, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
|
||
|
||
#print('#####line224 fontScale:',fontScale,' thickness:',tf,' line_thickness:',font['line_thickness'],' boxLine thickness:',box_tl)
|
||
return img
|
||
|
||
def plot_wh_methods(): # from utils.plots import *; plot_wh_methods()
|
||
# Compares the two methods for width-height anchor multiplication
|
||
# https://github.com/ultralytics/yolov3/issues/168
|
||
x = np.arange(-4.0, 4.0, .1)
|
||
ya = np.exp(x)
|
||
yb = torch.sigmoid(torch.from_numpy(x)).numpy() * 2
|
||
|
||
fig = plt.figure(figsize=(6, 3), tight_layout=True)
|
||
plt.plot(x, ya, '.-', label='YOLOv3')
|
||
plt.plot(x, yb ** 2, '.-', label='YOLOv5 ^2')
|
||
plt.plot(x, yb ** 1.6, '.-', label='YOLOv5 ^1.6')
|
||
plt.xlim(left=-4, right=4)
|
||
plt.ylim(bottom=0, top=6)
|
||
plt.xlabel('input')
|
||
plt.ylabel('output')
|
||
plt.grid()
|
||
plt.legend()
|
||
fig.savefig('comparison.png', dpi=200)
|
||
|
||
|
||
def output_to_target(output):
|
||
# Convert model output to target format [batch_id, class_id, x, y, w, h, conf]
|
||
targets = []
|
||
for i, o in enumerate(output):
|
||
for *box, conf, cls in o.cpu().numpy():
|
||
targets.append([i, cls, *list(*xyxy2xywh(np.array(box)[None])), conf])
|
||
return np.array(targets)
|
||
|
||
|
||
def plot_images(images, targets, paths=None, fname='images.jpg', names=None, max_size=640, max_subplots=16):
|
||
# Plot image grid with labels
|
||
|
||
if isinstance(images, torch.Tensor):
|
||
images = images.cpu().float().numpy()
|
||
if isinstance(targets, torch.Tensor):
|
||
targets = targets.cpu().numpy()
|
||
|
||
# un-normalise
|
||
if np.max(images[0]) <= 1:
|
||
images *= 255
|
||
|
||
tl = 3 # line thickness
|
||
tf = max(tl - 1, 1) # font thickness
|
||
bs, _, h, w = images.shape # batch size, _, height, width
|
||
bs = min(bs, max_subplots) # limit plot images
|
||
ns = np.ceil(bs ** 0.5) # number of subplots (square)
|
||
|
||
# Check if we should resize
|
||
scale_factor = max_size / max(h, w)
|
||
if scale_factor < 1:
|
||
h = math.ceil(scale_factor * h)
|
||
w = math.ceil(scale_factor * w)
|
||
|
||
colors = color_list() # list of colors
|
||
mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init
|
||
for i, img in enumerate(images):
|
||
if i == max_subplots: # if last batch has fewer images than we expect
|
||
break
|
||
|
||
block_x = int(w * (i // ns))
|
||
block_y = int(h * (i % ns))
|
||
|
||
img = img.transpose(1, 2, 0)
|
||
if scale_factor < 1:
|
||
img = cv2.resize(img, (w, h))
|
||
|
||
mosaic[block_y:block_y + h, block_x:block_x + w, :] = img
|
||
if len(targets) > 0:
|
||
image_targets = targets[targets[:, 0] == i]
|
||
boxes = xywh2xyxy(image_targets[:, 2:6]).T
|
||
classes = image_targets[:, 1].astype('int')
|
||
labels = image_targets.shape[1] == 6 # labels if no conf column
|
||
conf = None if labels else image_targets[:, 6] # check for confidence presence (label vs pred)
|
||
|
||
if boxes.shape[1]:
|
||
if boxes.max() <= 1.01: # if normalized with tolerance 0.01
|
||
boxes[[0, 2]] *= w # scale to pixels
|
||
boxes[[1, 3]] *= h
|
||
elif scale_factor < 1: # absolute coords need scale if image scales
|
||
boxes *= scale_factor
|
||
boxes[[0, 2]] += block_x
|
||
boxes[[1, 3]] += block_y
|
||
for j, box in enumerate(boxes.T):
|
||
cls = int(classes[j])
|
||
color = colors[cls % len(colors)]
|
||
cls = names[cls] if names else cls
|
||
if labels or conf[j] > 0.25: # 0.25 conf thresh
|
||
label = '%s' % cls if labels else '%s %.1f' % (cls, conf[j])
|
||
plot_one_box(box, mosaic, label=label, color=color, line_thickness=tl)
|
||
|
||
# Draw image filename labels
|
||
if paths:
|
||
label = Path(paths[i]).name[:40] # trim to 40 char
|
||
t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
|
||
cv2.putText(mosaic, label, (block_x + 5, block_y + t_size[1] + 5), 0, tl / 3, [220, 220, 220], thickness=tf,
|
||
lineType=cv2.LINE_AA)
|
||
|
||
# Image border
|
||
cv2.rectangle(mosaic, (block_x, block_y), (block_x + w, block_y + h), (255, 255, 255), thickness=3)
|
||
|
||
if fname:
|
||
r = min(1280. / max(h, w) / ns, 1.0) # ratio to limit image size
|
||
mosaic = cv2.resize(mosaic, (int(ns * w * r), int(ns * h * r)), interpolation=cv2.INTER_AREA)
|
||
# cv2.imwrite(fname, cv2.cvtColor(mosaic, cv2.COLOR_BGR2RGB)) # cv2 save
|
||
Image.fromarray(mosaic).save(fname) # PIL save
|
||
return mosaic
|
||
|
||
|
||
def plot_lr_scheduler(optimizer, scheduler, epochs=300, save_dir=''):
|
||
# Plot LR simulating training for full epochs
|
||
optimizer, scheduler = copy(optimizer), copy(scheduler) # do not modify originals
|
||
y = []
|
||
for _ in range(epochs):
|
||
scheduler.step()
|
||
y.append(optimizer.param_groups[0]['lr'])
|
||
plt.plot(y, '.-', label='LR')
|
||
plt.xlabel('epoch')
|
||
plt.ylabel('LR')
|
||
plt.grid()
|
||
plt.xlim(0, epochs)
|
||
plt.ylim(0)
|
||
plt.savefig(Path(save_dir) / 'LR.png', dpi=200)
|
||
plt.close()
|
||
|
||
|
||
def plot_test_txt(): # from utils.plots import *; plot_test()
|
||
# Plot test.txt histograms
|
||
x = np.loadtxt('test.txt', dtype=np.float32)
|
||
box = xyxy2xywh(x[:, :4])
|
||
cx, cy = box[:, 0], box[:, 1]
|
||
|
||
fig, ax = plt.subplots(1, 1, figsize=(6, 6), tight_layout=True)
|
||
ax.hist2d(cx, cy, bins=600, cmax=10, cmin=0)
|
||
ax.set_aspect('equal')
|
||
plt.savefig('hist2d.png', dpi=300)
|
||
|
||
fig, ax = plt.subplots(1, 2, figsize=(12, 6), tight_layout=True)
|
||
ax[0].hist(cx, bins=600)
|
||
ax[1].hist(cy, bins=600)
|
||
plt.savefig('hist1d.png', dpi=200)
|
||
|
||
|
||
def plot_targets_txt(): # from utils.plots import *; plot_targets_txt()
|
||
# Plot targets.txt histograms
|
||
x = np.loadtxt('targets.txt', dtype=np.float32).T
|
||
s = ['x targets', 'y targets', 'width targets', 'height targets']
|
||
fig, ax = plt.subplots(2, 2, figsize=(8, 8), tight_layout=True)
|
||
ax = ax.ravel()
|
||
for i in range(4):
|
||
ax[i].hist(x[i], bins=100, label='%.3g +/- %.3g' % (x[i].mean(), x[i].std()))
|
||
ax[i].legend()
|
||
ax[i].set_title(s[i])
|
||
plt.savefig('targets.jpg', dpi=200)
|
||
|
||
|
||
def plot_study_txt(path='', x=None): # from utils.plots import *; plot_study_txt()
|
||
# Plot study.txt generated by test.py
|
||
fig, ax = plt.subplots(2, 4, figsize=(10, 6), tight_layout=True)
|
||
# ax = ax.ravel()
|
||
|
||
fig2, ax2 = plt.subplots(1, 1, figsize=(8, 4), tight_layout=True)
|
||
# for f in [Path(path) / f'study_coco_{x}.txt' for x in ['yolov5s6', 'yolov5m6', 'yolov5l6', 'yolov5x6']]:
|
||
for f in sorted(Path(path).glob('study*.txt')):
|
||
y = np.loadtxt(f, dtype=np.float32, usecols=[0, 1, 2, 3, 7, 8, 9], ndmin=2).T
|
||
x = np.arange(y.shape[1]) if x is None else np.array(x)
|
||
s = ['P', 'R', 'mAP@.5', 'mAP@.5:.95', 't_inference (ms/img)', 't_NMS (ms/img)', 't_total (ms/img)']
|
||
# for i in range(7):
|
||
# ax[i].plot(x, y[i], '.-', linewidth=2, markersize=8)
|
||
# ax[i].set_title(s[i])
|
||
|
||
j = y[3].argmax() + 1
|
||
ax2.plot(y[6, 1:j], y[3, 1:j] * 1E2, '.-', linewidth=2, markersize=8,
|
||
label=f.stem.replace('study_coco_', '').replace('yolo', 'YOLO'))
|
||
|
||
ax2.plot(1E3 / np.array([209, 140, 97, 58, 35, 18]), [34.6, 40.5, 43.0, 47.5, 49.7, 51.5],
|
||
'k.-', linewidth=2, markersize=8, alpha=.25, label='EfficientDet')
|
||
|
||
ax2.grid(alpha=0.2)
|
||
ax2.set_yticks(np.arange(20, 60, 5))
|
||
ax2.set_xlim(0, 57)
|
||
ax2.set_ylim(30, 55)
|
||
ax2.set_xlabel('GPU Speed (ms/img)')
|
||
ax2.set_ylabel('COCO AP val')
|
||
ax2.legend(loc='lower right')
|
||
plt.savefig(str(Path(path).name) + '.png', dpi=300)
|
||
|
||
|
||
def plot_labels(labels, names=(), save_dir=Path(''), loggers=None):
|
||
# plot dataset labels
|
||
print('Plotting labels... ')
|
||
c, b = labels[:, 0], labels[:, 1:].transpose() # classes, boxes
|
||
nc = int(c.max() + 1) # number of classes
|
||
colors = color_list()
|
||
x = pd.DataFrame(b.transpose(), columns=['x', 'y', 'width', 'height'])
|
||
|
||
# seaborn correlogram
|
||
sns.pairplot(x, corner=True, diag_kind='auto', kind='hist', diag_kws=dict(bins=50), plot_kws=dict(pmax=0.9))
|
||
plt.savefig(save_dir / 'labels_correlogram.jpg', dpi=200)
|
||
plt.close()
|
||
|
||
# matplotlib labels
|
||
matplotlib.use('svg') # faster
|
||
ax = plt.subplots(2, 2, figsize=(8, 8), tight_layout=True)[1].ravel()
|
||
ax[0].hist(c, bins=np.linspace(0, nc, nc + 1) - 0.5, rwidth=0.8)
|
||
ax[0].set_ylabel('instances')
|
||
if 0 < len(names) < 30:
|
||
ax[0].set_xticks(range(len(names)))
|
||
ax[0].set_xticklabels(names, rotation=90, fontsize=10)
|
||
else:
|
||
ax[0].set_xlabel('classes')
|
||
sns.histplot(x, x='x', y='y', ax=ax[2], bins=50, pmax=0.9)
|
||
sns.histplot(x, x='width', y='height', ax=ax[3], bins=50, pmax=0.9)
|
||
|
||
# rectangles
|
||
labels[:, 1:3] = 0.5 # center
|
||
labels[:, 1:] = xywh2xyxy(labels[:, 1:]) * 2000
|
||
img = Image.fromarray(np.ones((2000, 2000, 3), dtype=np.uint8) * 255)
|
||
for cls, *box in labels[:1000]:
|
||
ImageDraw.Draw(img).rectangle(box, width=1, outline=colors[int(cls) % 10]) # plot
|
||
ax[1].imshow(img)
|
||
ax[1].axis('off')
|
||
|
||
for a in [0, 1, 2, 3]:
|
||
for s in ['top', 'right', 'left', 'bottom']:
|
||
ax[a].spines[s].set_visible(False)
|
||
|
||
plt.savefig(save_dir / 'labels.jpg', dpi=200)
|
||
matplotlib.use('Agg')
|
||
plt.close()
|
||
|
||
# loggers
|
||
for k, v in loggers.items() or {}:
|
||
if k == 'wandb' and v:
|
||
v.log({"Labels": [v.Image(str(x), caption=x.name) for x in save_dir.glob('*labels*.jpg')]}, commit=False)
|
||
|
||
|
||
def plot_evolution(yaml_file='data/hyp.finetune.yaml'): # from utils.plots import *; plot_evolution()
|
||
# Plot hyperparameter evolution results in evolve.txt
|
||
with open(yaml_file) as f:
|
||
hyp = yaml.load(f, Loader=yaml.SafeLoader)
|
||
x = np.loadtxt('evolve.txt', ndmin=2)
|
||
f = fitness(x)
|
||
# weights = (f - f.min()) ** 2 # for weighted results
|
||
plt.figure(figsize=(10, 12), tight_layout=True)
|
||
matplotlib.rc('font', **{'size': 8})
|
||
for i, (k, v) in enumerate(hyp.items()):
|
||
y = x[:, i + 7]
|
||
# mu = (y * weights).sum() / weights.sum() # best weighted result
|
||
mu = y[f.argmax()] # best single result
|
||
plt.subplot(6, 5, i + 1)
|
||
plt.scatter(y, f, c=hist2d(y, f, 20), cmap='viridis', alpha=.8, edgecolors='none')
|
||
plt.plot(mu, f.max(), 'k+', markersize=15)
|
||
plt.title('%s = %.3g' % (k, mu), fontdict={'size': 9}) # limit to 40 characters
|
||
if i % 5 != 0:
|
||
plt.yticks([])
|
||
print('%15s: %.3g' % (k, mu))
|
||
plt.savefig('evolve.png', dpi=200)
|
||
print('\nPlot saved as evolve.png')
|
||
|
||
|
||
def profile_idetection(start=0, stop=0, labels=(), save_dir=''):
|
||
# Plot iDetection '*.txt' per-image logs. from utils.plots import *; profile_idetection()
|
||
ax = plt.subplots(2, 4, figsize=(12, 6), tight_layout=True)[1].ravel()
|
||
s = ['Images', 'Free Storage (GB)', 'RAM Usage (GB)', 'Battery', 'dt_raw (ms)', 'dt_smooth (ms)', 'real-world FPS']
|
||
files = list(Path(save_dir).glob('frames*.txt'))
|
||
for fi, f in enumerate(files):
|
||
try:
|
||
results = np.loadtxt(f, ndmin=2).T[:, 90:-30] # clip first and last rows
|
||
n = results.shape[1] # number of rows
|
||
x = np.arange(start, min(stop, n) if stop else n)
|
||
results = results[:, x]
|
||
t = (results[0] - results[0].min()) # set t0=0s
|
||
results[0] = x
|
||
for i, a in enumerate(ax):
|
||
if i < len(results):
|
||
label = labels[fi] if len(labels) else f.stem.replace('frames_', '')
|
||
a.plot(t, results[i], marker='.', label=label, linewidth=1, markersize=5)
|
||
a.set_title(s[i])
|
||
a.set_xlabel('time (s)')
|
||
# if fi == len(files) - 1:
|
||
# a.set_ylim(bottom=0)
|
||
for side in ['top', 'right']:
|
||
a.spines[side].set_visible(False)
|
||
else:
|
||
a.remove()
|
||
except Exception as e:
|
||
print('Warning: Plotting error for %s; %s' % (f, e))
|
||
|
||
ax[1].legend()
|
||
plt.savefig(Path(save_dir) / 'idetection_profile.png', dpi=200)
|
||
|
||
|
||
def plot_results_overlay(start=0, stop=0): # from utils.plots import *; plot_results_overlay()
|
||
# Plot training 'results*.txt', overlaying train and val losses
|
||
s = ['train', 'train', 'train', 'Precision', 'mAP@0.5', 'val', 'val', 'val', 'Recall', 'mAP@0.5:0.95'] # legends
|
||
t = ['Box', 'Objectness', 'Classification', 'P-R', 'mAP-F1'] # titles
|
||
for f in sorted(glob.glob('results*.txt') + glob.glob('../../Downloads/results*.txt')):
|
||
results = np.loadtxt(f, usecols=[2, 3, 4, 8, 9, 12, 13, 14, 10, 11], ndmin=2).T
|
||
n = results.shape[1] # number of rows
|
||
x = range(start, min(stop, n) if stop else n)
|
||
fig, ax = plt.subplots(1, 5, figsize=(14, 3.5), tight_layout=True)
|
||
ax = ax.ravel()
|
||
for i in range(5):
|
||
for j in [i, i + 5]:
|
||
y = results[j, x]
|
||
ax[i].plot(x, y, marker='.', label=s[j])
|
||
# y_smooth = butter_lowpass_filtfilt(y)
|
||
# ax[i].plot(x, np.gradient(y_smooth), marker='.', label=s[j])
|
||
|
||
ax[i].set_title(t[i])
|
||
ax[i].legend()
|
||
ax[i].set_ylabel(f) if i == 0 else None # add filename
|
||
fig.savefig(f.replace('.txt', '.png'), dpi=200)
|
||
|
||
|
||
def plot_results(start=0, stop=0, bucket='', id=(), labels=(), save_dir=''):
|
||
# Plot training 'results*.txt'. from utils.plots import *; plot_results(save_dir='runs/train/exp')
|
||
fig, ax = plt.subplots(2, 5, figsize=(12, 6), tight_layout=True)
|
||
ax = ax.ravel()
|
||
s = ['Box', 'Objectness', 'Classification', 'Precision', 'Recall',
|
||
'val Box', 'val Objectness', 'val Classification', 'mAP@0.5', 'mAP@0.5:0.95']
|
||
if bucket:
|
||
# files = ['https://storage.googleapis.com/%s/results%g.txt' % (bucket, x) for x in id]
|
||
files = ['results%g.txt' % x for x in id]
|
||
c = ('gsutil cp ' + '%s ' * len(files) + '.') % tuple('gs://%s/results%g.txt' % (bucket, x) for x in id)
|
||
os.system(c)
|
||
else:
|
||
files = list(Path(save_dir).glob('results*.txt'))
|
||
assert len(files), 'No results.txt files found in %s, nothing to plot.' % os.path.abspath(save_dir)
|
||
for fi, f in enumerate(files):
|
||
try:
|
||
results = np.loadtxt(f, usecols=[2, 3, 4, 8, 9, 12, 13, 14, 10, 11], ndmin=2).T
|
||
n = results.shape[1] # number of rows
|
||
x = range(start, min(stop, n) if stop else n)
|
||
for i in range(10):
|
||
y = results[i, x]
|
||
if i in [0, 1, 2, 5, 6, 7]:
|
||
y[y == 0] = np.nan # don't show zero loss values
|
||
# y /= y[0] # normalize
|
||
label = labels[fi] if len(labels) else f.stem
|
||
ax[i].plot(x, y, marker='.', label=label, linewidth=2, markersize=8)
|
||
ax[i].set_title(s[i])
|
||
# if i in [5, 6, 7]: # share train and val loss y axes
|
||
# ax[i].get_shared_y_axes().join(ax[i], ax[i - 5])
|
||
except Exception as e:
|
||
print('Warning: Plotting error for %s; %s' % (f, e))
|
||
|
||
ax[1].legend()
|
||
fig.savefig(Path(save_dir) / 'results.png', dpi=200)
|