id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2,289,500 | detect.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/detect.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Run inference on images, videos, directories, streams, etc.
Usage - sources:
$ python path/to/detect.py --weights yolov5s.pt --source 0 # webcam
img.jpg # image
vid.mp4 # video
path/ # directory
path/*.jpg # glob
'https://youtu.be/Zgi9g1ksQHc' # YouTube
'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream
Usage - formats:
$ python path/to/detect.py --weights yolov5s.pt # PyTorch
yolov5s.torchscript # TorchScript
yolov5s.onnx # ONNX Runtime or OpenCV DNN with --dnn
yolov5s.xml # OpenVINO
yolov5s.engine # TensorRT
yolov5s.mlmodel # CoreML (macOS-only)
yolov5s_saved_model # TensorFlow SavedModel
yolov5s.pb # TensorFlow GraphDef
yolov5s.tflite # TensorFlow Lite
yolov5s_edgetpu.tflite # TensorFlow Edge TPU
"""
import argparse
import os
import platform
import sys
from pathlib import Path
import torch
import torch.backends.cudnn as cudnn
FILE = Path(__file__).resolve()
ROOT = FILE.parents[0] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from models.common import DetectMultiBackend
from utils.dataloaders import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreams
from utils.general import (LOGGER, check_file, check_img_size, check_imshow, check_requirements, colorstr, cv2,
increment_path, non_max_suppression, print_args, scale_coords, strip_optimizer, xyxy2xywh)
from utils.plots import Annotator, colors, save_one_box
from utils.torch_utils import select_device, smart_inference_mode, time_sync
@smart_inference_mode()
def run(
weights=ROOT / 'yolov5s.pt', # model.pt path(s)
source=ROOT / 'data/images', # file/dir/URL/glob, 0 for webcam
data=ROOT / 'data/coco128.yaml', # dataset.yaml path
imgsz=(640, 640), # inference size (height, width)
conf_thres=0.25, # confidence threshold
iou_thres=0.45, # NMS IOU threshold
max_det=1000, # maximum detections per image
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
view_img=False, # show results
save_txt=False, # save results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_crop=False, # save cropped prediction boxes
nosave=False, # do not save images/videos
classes=None, # filter by class: --class 0, or --class 0 2 3
agnostic_nms=False, # class-agnostic NMS
augment=False, # augmented inference
visualize=False, # visualize features
update=False, # update all models
project=ROOT / 'runs/detect', # save results to project/name
name='exp', # save results to project/name
exist_ok=False, # existing project/name ok, do not increment
line_thickness=3, # bounding box thickness (pixels)
hide_labels=False, # hide labels
hide_conf=False, # hide confidences
half=False, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
):
source = str(source)
save_img = not nosave and not source.endswith('.txt') # save inference images
is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))
webcam = source.isnumeric() or source.endswith('.txt') or (is_url and not is_file)
if is_url and is_file:
source = check_file(source) # download
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
device = select_device(device)
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
stride, names, pt = model.stride, model.names, model.pt
imgsz = check_img_size(imgsz, s=stride) # check image size
# Dataloader
if webcam:
view_img = check_imshow()
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt)
bs = len(dataset) # batch_size
else:
dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt)
bs = 1 # batch_size
vid_path, vid_writer = [None] * bs, [None] * bs
# Run inference
model.warmup(imgsz=(1 if pt else bs, 3, *imgsz)) # warmup
seen, windows, dt = 0, [], [0.0, 0.0, 0.0]
for path, im, im0s, vid_cap, s in dataset:
t1 = time_sync()
im = torch.from_numpy(im).to(device)
im = im.half() if model.fp16 else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
if len(im.shape) == 3:
im = im[None] # expand for batch dim
t2 = time_sync()
dt[0] += t2 - t1
# Inference
visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False
pred = model(im, augment=augment, visualize=visualize)
t3 = time_sync()
dt[1] += t3 - t2
# NMS
pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det)
dt[2] += time_sync() - t3
# Second-stage classifier (optional)
# pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
# Process predictions
for i, det in enumerate(pred): # per image
seen += 1
if webcam: # batch_size >= 1
p, im0, frame = path[i], im0s[i].copy(), dataset.count
s += f'{i}: '
else:
p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # im.jpg
txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # im.txt
s += '%gx%g ' % im.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
imc = im0.copy() if save_crop else im0 # for save_crop
annotator = Annotator(im0, line_width=line_thickness, example=str(names))
if len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
if save_txt: # Write to file
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format
with open(f'{txt_path}.txt', 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
if save_img or save_crop or view_img: # Add bbox to image
c = int(cls) # integer class
label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')
annotator.box_label(xyxy, label, color=colors(c, True))
if save_crop:
save_one_box(xyxy, imc, file=save_dir / 'crops' / names[c] / f'{p.stem}.jpg', BGR=True)
# Stream results
im0 = annotator.result()
if view_img:
if platform.system() == 'Linux' and p not in windows:
windows.append(p)
cv2.namedWindow(str(p), cv2.WINDOW_NORMAL | cv2.WINDOW_KEEPRATIO) # allow window resize (Linux)
cv2.resizeWindow(str(p), im0.shape[1], im0.shape[0])
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == 'image':
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path[i] != save_path: # new video
vid_path[i] = save_path
if isinstance(vid_writer[i], cv2.VideoWriter):
vid_writer[i].release() # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path = str(Path(save_path).with_suffix('.mp4')) # force *.mp4 suffix on results videos
vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
vid_writer[i].write(im0)
# Print time (inference-only)
LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')
# Print results
t = tuple(x / seen * 1E3 for x in dt) # speeds per image
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
if update:
strip_optimizer(weights[0]) # update model (to fix SourceChangeWarning)
def parse_opt():
parser = argparse.ArgumentParser()
# `--weights` (â�)指定æ�ƒé‡�，ä¸�指定的è¯�会使用yolov5s.pt预è®ç»ƒæ�ƒé‡�
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'weights/yolov5s.pt', help='model path(s)')
# `--source` (â�)指定检测æ�¥æº�，详è§�上é�¢çš„介ç»�
parser.add_argument('--source', type=str, default=ROOT / 'dataset/testset', help='file/dir/URL/glob, 0 for webcam')
parser.add_argument('--data', type=str, default=ROOT / 'data/TACO.yaml', help='(optional) dataset.yaml path')
# `--img-size` `--imgsz` `--img` (â�)指定æ�¨ç�†å›¾ç‰‡åˆ†è¾¨ç�‡ï¼Œé»˜è®¤640ï¼Œä¸‰ä¸ªæŒ‡ä»¤ä¸€æ ·
parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[640], help='inference size h,w')
# `--conf-thres` (â�)指定置信度阈值，默认0.4，也å�¯ä½¿ç”¨`--conf`
parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')
# `--iou-thres` 指定NMS(��大值抑制)的IOU阈值，默认0.5
parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')
# `--max-det` æ¯�å¼ å›¾æœ€å¤šæ£€æµ‹å¤šå°‘ç›®æ ‡
parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')
# `--device` 指定设备，如`--device 0` `--device 0,1,2,3` `--device cpu`
# v6.2 已支�Apple Silicon MPS support for Apple M1/M2 devices with --device mps
# https://github.com/pytorch/pytorch/issues/77764
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--view-img', action='store_true', help='show results')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')
parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
# `--classes` �检测特定的类，如`--classes 0 2 4 6 8`
parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')
parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--visualize', action='store_true', help='visualize features')
parser.add_argument('--update', action='store_true', help='update all models')
# `--project` 指定结æ�œå˜æ”¾è·¯å¾„，默认./runs/detect/
parser.add_argument('--project', default=ROOT / 'runs/detect', help='save results to project/name')
# `--name` 指定结æ�œå˜æ”¾å��,默认exp
parser.add_argument('--name', default='exp', help='save results to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
# `--line-thickness` 画图时线�宽度
parser.add_argument('--line-thickness', default=3, type=int, help='bounding box thickness (pixels)')
parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')
parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
opt = parser.parse_args()
opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand
print_args(vars(opt))
return opt
# æ— å�‚指令
# `--view-img` 图片形�显示结�
# `--save-txt` è¾“å‡ºæ ‡ç¾ç»“æ�œ(yoloæ ¼å¼�)
# `--save-conf` åœ¨è¾“å‡ºæ ‡ç¾ç»“æ�œtxtä¸å�Œæ ·å†™å…¥æ¯�ä¸ªç›®æ ‡çš„ç½®ä¿¡åº¦
# `--save-crop` ä»�图片\è§†é¢‘ä¸ŠæŠŠæ£€æµ‹åˆ°çš„ç›®æ ‡æŠ å‡ºæ�¥ä¿�å˜
# `--nosave` ä¸�ä¿�å˜å›¾ç‰‡/视频
# `--agnostic-nms` 使用agnostic NMS(�背景)
# `--augment` �强识别，速度会慢�少。[详情](https://github.com/ultralytics/yolov5/issues/303)
# `--visualize` 特��视化
# `--update` 更新所有模�
# `--exist-ok` 若���覆盖
# `--hide-labels` éš�è—�æ ‡ç¾
# `--hide-conf` ��置信度
# `--half` �精度检测(FP16)
# `--dnn` 在onnxæ�¨ç�†ä¸ä½¿ç”¨OpenCV DNN
def main(opt):
check_requirements(exclude=('tensorboard', 'thop'))
run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 15,325 | Python | .py | 255 | 48.321569 | 120 | 0.56363 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,501 | hubconf.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/hubconf.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
PyTorch Hub models https://pytorch.org/hub/ultralytics_yolov5/
Usage:
import torch
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
model = torch.hub.load('ultralytics/yolov5:master', 'custom', 'path/to/yolov5s.onnx') # file from branch
"""
import torch
def _create(name, pretrained=True, channels=3, classes=80, autoshape=True, verbose=True, device=None):
"""Creates or loads a YOLOv5 model
Arguments:
name (str): model name 'yolov5s' or path 'path/to/best.pt'
pretrained (bool): load pretrained weights into the model
channels (int): number of input channels
classes (int): number of model classes
autoshape (bool): apply YOLOv5 .autoshape() wrapper to model
verbose (bool): print all information to screen
device (str, torch.device, None): device to use for model parameters
Returns:
YOLOv5 model
"""
from pathlib import Path
from models.common import AutoShape, DetectMultiBackend
from models.experimental import attempt_load
from models.yolo import Model
from utils.downloads import attempt_download
from utils.general import LOGGER, check_requirements, intersect_dicts, logging
from utils.torch_utils import select_device
if not verbose:
LOGGER.setLevel(logging.WARNING)
check_requirements(exclude=('tensorboard', 'thop', 'opencv-python'))
name = Path(name)
path = name.with_suffix('.pt') if name.suffix == '' and not name.is_dir() else name # checkpoint path
try:
device = select_device(device)
if pretrained and channels == 3 and classes == 80:
try:
model = DetectMultiBackend(path, device=device, fuse=autoshape) # detection model
if autoshape:
model = AutoShape(model) # for file/URI/PIL/cv2/np inputs and NMS
except Exception:
model = attempt_load(path, device=device, fuse=False) # arbitrary model
else:
cfg = list((Path(__file__).parent / 'models').rglob(f'{path.stem}.yaml'))[0] # model.yaml path
model = Model(cfg, channels, classes) # create model
if pretrained:
ckpt = torch.load(attempt_download(path), map_location=device) # load
csd = ckpt['model'].float().state_dict() # checkpoint state_dict as FP32
csd = intersect_dicts(csd, model.state_dict(), exclude=['anchors']) # intersect
model.load_state_dict(csd, strict=False) # load
if len(ckpt['model'].names) == classes:
model.names = ckpt['model'].names # set class names attribute
if not verbose:
LOGGER.setLevel(logging.INFO) # reset to default
return model.to(device)
except Exception as e:
help_url = 'https://github.com/ultralytics/yolov5/issues/36'
s = f'{e}. Cache may be out of date, try `force_reload=True` or see {help_url} for help.'
raise Exception(s) from e
def custom(path='path/to/model.pt', autoshape=True, _verbose=True, device=None):
# YOLOv5 custom or local model
return _create(path, autoshape=autoshape, verbose=_verbose, device=device)
def yolov5n(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-nano model https://github.com/ultralytics/yolov5
return _create('yolov5n', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5s(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-small model https://github.com/ultralytics/yolov5
return _create('yolov5s', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5m(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-medium model https://github.com/ultralytics/yolov5
return _create('yolov5m', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5l(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-large model https://github.com/ultralytics/yolov5
return _create('yolov5l', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5x(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-xlarge model https://github.com/ultralytics/yolov5
return _create('yolov5x', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5n6(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-nano-P6 model https://github.com/ultralytics/yolov5
return _create('yolov5n6', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5s6(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-small-P6 model https://github.com/ultralytics/yolov5
return _create('yolov5s6', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5m6(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-medium-P6 model https://github.com/ultralytics/yolov5
return _create('yolov5m6', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5l6(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-large-P6 model https://github.com/ultralytics/yolov5
return _create('yolov5l6', pretrained, channels, classes, autoshape, _verbose, device)
def yolov5x6(pretrained=True, channels=3, classes=80, autoshape=True, _verbose=True, device=None):
# YOLOv5-xlarge-P6 model https://github.com/ultralytics/yolov5
return _create('yolov5x6', pretrained, channels, classes, autoshape, _verbose, device)
if __name__ == '__main__':
import argparse
from pathlib import Path
import numpy as np
from PIL import Image
from utils.general import cv2, print_args
# Argparser
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='yolov5s', help='model name')
opt = parser.parse_args()
print_args(vars(opt))
# Model
model = _create(name=opt.model, pretrained=True, channels=3, classes=80, autoshape=True, verbose=True)
# model = custom(path='path/to/model.pt') # custom
# Images
imgs = [
'data/images/zidane.jpg', # filename
Path('data/images/zidane.jpg'), # Path
'https://ultralytics.com/images/zidane.jpg', # URI
cv2.imread('data/images/bus.jpg')[:, :, ::-1], # OpenCV
Image.open('data/images/bus.jpg'), # PIL
np.zeros((320, 640, 3))] # numpy
# Inference
results = model(imgs, size=320) # batched inference
# Results
results.print()
results.save()
| 6,842 | Python | .py | 120 | 50.083333 | 109 | 0.692457 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,502 | yolo.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/models/yolo.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
YOLO-specific modules
Usage:
$ python path/to/models/yolo.py --cfg yolov5s.yaml
"""
import argparse
import contextlib
import os
import platform
import sys
from copy import deepcopy
from pathlib import Path
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
if platform.system() != 'Windows':
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from models.common import *
from models.experimental import *
from utils.autoanchor import check_anchor_order
from utils.general import LOGGER, check_version, check_yaml, make_divisible, print_args
from utils.plots import feature_visualization
from utils.torch_utils import (fuse_conv_and_bn, initialize_weights, model_info, profile, scale_img, select_device,
time_sync)
try:
import thop # for FLOPs computation
except ImportError:
thop = None
class Detect(nn.Module):
stride = None # strides computed during build
onnx_dynamic = False # ONNX export parameter
export = False # export mode
def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detection layer
super().__init__()
self.nc = nc # number of classes
self.no = nc + 5 # number of outputs per anchor
self.nl = len(anchors) # number of detection layers
self.na = len(anchors[0]) // 2 # number of anchors
self.grid = [torch.zeros(1)] * self.nl # init grid
self.anchor_grid = [torch.zeros(1)] * self.nl # init anchor grid
self.register_buffer('anchors', torch.tensor(anchors).float().view(self.nl, -1, 2)) # shape(nl,na,2)
self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv
self.inplace = inplace # use inplace ops (e.g. slice assignment)
def forward(self, x):
z = [] # inference output
for i in range(self.nl):
x[i] = self.m[i](x[i]) # conv
bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
if not self.training: # inference
if self.onnx_dynamic or self.grid[i].shape[2:4] != x[i].shape[2:4]:
self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i)
y = x[i].sigmoid()
if self.inplace:
y[..., 0:2] = (y[..., 0:2] * 2 + self.grid[i]) * self.stride[i] # xy
y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh
else: # for YOLOv5 on AWS Inferentia https://github.com/ultralytics/yolov5/pull/2953
xy, wh, conf = y.split((2, 2, self.nc + 1), 4) # y.tensor_split((2, 4, 5), 4) # torch 1.8.0
xy = (xy * 2 + self.grid[i]) * self.stride[i] # xy
wh = (wh * 2) ** 2 * self.anchor_grid[i] # wh
y = torch.cat((xy, wh, conf), 4)
z.append(y.view(bs, -1, self.no))
return x if self.training else (torch.cat(z, 1),) if self.export else (torch.cat(z, 1), x)
def _make_grid(self, nx=20, ny=20, i=0, torch_1_10=check_version(torch.__version__, '1.10.0')):
d = self.anchors[i].device
t = self.anchors[i].dtype
shape = 1, self.na, ny, nx, 2 # grid shape
y, x = torch.arange(ny, device=d, dtype=t), torch.arange(nx, device=d, dtype=t)
if torch_1_10: # torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility
yv, xv = torch.meshgrid(y, x, indexing='ij')
else:
yv, xv = torch.meshgrid(y, x)
grid = torch.stack((xv, yv), 2).expand(shape) - 0.5 # add grid offset, i.e. y = 2.0 * x - 0.5
anchor_grid = (self.anchors[i] * self.stride[i]).view((1, self.na, 1, 1, 2)).expand(shape)
return grid, anchor_grid
class BaseModel(nn.Module):
# YOLOv5 base model
def forward(self, x, profile=False, visualize=False):
return self._forward_once(x, profile, visualize) # single-scale inference, train
def _forward_once(self, x, profile=False, visualize=False):
y, dt = [], [] # outputs
for m in self.model:
if m.f != -1: # if not from previous layer
x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layers
if profile:
self._profile_one_layer(m, x, dt)
x = m(x) # run
y.append(x if m.i in self.save else None) # save output
if visualize:
feature_visualization(x, m.type, m.i, save_dir=visualize)
return x
def _profile_one_layer(self, m, x, dt):
c = m == self.model[-1] # is final layer, copy input as inplace fix
o = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] / 1E9 * 2 if thop else 0 # FLOPs
t = time_sync()
for _ in range(10):
m(x.copy() if c else x)
dt.append((time_sync() - t) * 100)
if m == self.model[0]:
LOGGER.info(f"{'time (ms)':>10s} {'GFLOPs':>10s} {'params':>10s} module")
LOGGER.info(f'{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f} {m.type}')
if c:
LOGGER.info(f"{sum(dt):10.2f} {'-':>10s} {'-':>10s} Total")
def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
LOGGER.info('Fusing layers... ')
for m in self.model.modules():
if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'):
m.conv = fuse_conv_and_bn(m.conv, m.bn) # update conv
delattr(m, 'bn') # remove batchnorm
m.forward = m.forward_fuse # update forward
self.info()
return self
def info(self, verbose=False, img_size=640): # print model information
model_info(self, verbose, img_size)
def _apply(self, fn):
# Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffers
self = super()._apply(fn)
m = self.model[-1] # Detect()
if isinstance(m, Detect):
m.stride = fn(m.stride)
m.grid = list(map(fn, m.grid))
if isinstance(m.anchor_grid, list):
m.anchor_grid = list(map(fn, m.anchor_grid))
return self
class DetectionModel(BaseModel):
# YOLOv5 detection model
def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None): # model, input channels, number of classes
super().__init__()
if isinstance(cfg, dict):
self.yaml = cfg # model dict
else: # is *.yaml
import yaml # for torch hub
self.yaml_file = Path(cfg).name
with open(cfg, encoding='ascii', errors='ignore') as f:
self.yaml = yaml.safe_load(f) # model dict
# Define model
ch = self.yaml['ch'] = self.yaml.get('ch', ch) # input channels
if nc and nc != self.yaml['nc']:
LOGGER.info(f"Overriding model.yaml nc={self.yaml['nc']} with nc={nc}")
self.yaml['nc'] = nc # override yaml value
if anchors:
LOGGER.info(f'Overriding model.yaml anchors with anchors={anchors}')
self.yaml['anchors'] = round(anchors) # override yaml value
self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch]) # model, savelist
self.names = [str(i) for i in range(self.yaml['nc'])] # default names
self.inplace = self.yaml.get('inplace', True)
# Build strides, anchors
m = self.model[-1] # Detect()
if isinstance(m, Detect):
s = 256 # 2x min stride
m.inplace = self.inplace
m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))]) # forward
check_anchor_order(m) # must be in pixel-space (not grid-space)
m.anchors /= m.stride.view(-1, 1, 1)
self.stride = m.stride
self._initialize_biases() # only run once
# Init weights, biases
initialize_weights(self)
self.info()
LOGGER.info('')
def forward(self, x, augment=False, profile=False, visualize=False):
if augment:
return self._forward_augment(x) # augmented inference, None
return self._forward_once(x, profile, visualize) # single-scale inference, train
def _forward_augment(self, x):
img_size = x.shape[-2:] # height, width
s = [1, 0.83, 0.67] # scales
f = [None, 3, None] # flips (2-ud, 3-lr)
y = [] # outputs
for si, fi in zip(s, f):
xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
yi = self._forward_once(xi)[0] # forward
# cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1]) # save
yi = self._descale_pred(yi, fi, si, img_size)
y.append(yi)
y = self._clip_augmented(y) # clip augmented tails
return torch.cat(y, 1), None # augmented inference, train
def _descale_pred(self, p, flips, scale, img_size):
# de-scale predictions following augmented inference (inverse operation)
if self.inplace:
p[..., :4] /= scale # de-scale
if flips == 2:
p[..., 1] = img_size[0] - p[..., 1] # de-flip ud
elif flips == 3:
p[..., 0] = img_size[1] - p[..., 0] # de-flip lr
else:
x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale # de-scale
if flips == 2:
y = img_size[0] - y # de-flip ud
elif flips == 3:
x = img_size[1] - x # de-flip lr
p = torch.cat((x, y, wh, p[..., 4:]), -1)
return p
def _clip_augmented(self, y):
# Clip YOLOv5 augmented inference tails
nl = self.model[-1].nl # number of detection layers (P3-P5)
g = sum(4 ** x for x in range(nl)) # grid points
e = 1 # exclude layer count
i = (y[0].shape[1] // g) * sum(4 ** x for x in range(e)) # indices
y[0] = y[0][:, :-i] # large
i = (y[-1].shape[1] // g) * sum(4 ** (nl - 1 - x) for x in range(e)) # indices
y[-1] = y[-1][:, i:] # small
return y
def _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency
# https://arxiv.org/abs/1708.02002 section 3.3
# cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
m = self.model[-1] # Detect() module
for mi, s in zip(m.m, m.stride): # from
b = mi.bias.view(m.na, -1).detach() # conv.bias(255) to (3,85)
b[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image)
b[:, 5:] += math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum()) # cls
mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)
Model = DetectionModel # retain YOLOv5 'Model' class for backwards compatibility
class ClassificationModel(BaseModel):
# YOLOv5 classification model
def __init__(self, cfg=None, model=None, nc=1000, cutoff=10): # yaml, model, number of classes, cutoff index
super().__init__()
self._from_detection_model(model, nc, cutoff) if model is not None else self._from_yaml(cfg)
def _from_detection_model(self, model, nc=1000, cutoff=10):
# Create a YOLOv5 classification model from a YOLOv5 detection model
if isinstance(model, DetectMultiBackend):
model = model.model # unwrap DetectMultiBackend
model.model = model.model[:cutoff] # backbone
m = model.model[-1] # last layer
ch = m.conv.in_channels if hasattr(m, 'conv') else m.cv1.conv.in_channels # ch into module
c = Classify(ch, nc) # Classify()
c.i, c.f, c.type = m.i, m.f, 'models.common.Classify' # index, from, type
model.model[-1] = c # replace
self.model = model.model
self.stride = model.stride
self.save = []
self.nc = nc
def _from_yaml(self, cfg):
# Create a YOLOv5 classification model from a *.yaml file
self.model = None
def parse_model(d, ch): # model_dict, input_channels(3)
LOGGER.info(f"\n{'':>3}{'from':>18}{'n':>3}{'params':>10} {'module':<40}{'arguments':<30}")
anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchors
no = na * (nc + 5) # number of outputs = anchors * (classes + 5)
layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out
for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, args
m = eval(m) if isinstance(m, str) else m # eval strings
for j, a in enumerate(args):
with contextlib.suppress(NameError):
args[j] = eval(a) if isinstance(a, str) else a # eval strings
n = n_ = max(round(n * gd), 1) if n > 1 else n # depth gain
if m in (Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x):
c1, c2 = ch[f], args[0]
if c2 != no: # if not output
c2 = make_divisible(c2 * gw, 8)
args = [c1, c2, *args[1:]]
if m in [BottleneckCSP, C3, C3TR, C3Ghost, C3x]:
args.insert(2, n) # number of repeats
n = 1
elif m is nn.BatchNorm2d:
args = [ch[f]]
elif m is Concat:
c2 = sum(ch[x] for x in f)
elif m is Detect:
args.append([ch[x] for x in f])
if isinstance(args[1], int): # number of anchors
args[1] = [list(range(args[1] * 2))] * len(f)
elif m is Contract:
c2 = ch[f] * args[0] ** 2
elif m is Expand:
c2 = ch[f] // args[0] ** 2
else:
c2 = ch[f]
m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args) # module
t = str(m)[8:-2].replace('__main__.', '') # module type
np = sum(x.numel() for x in m_.parameters()) # number params
m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params
LOGGER.info(f'{i:>3}{str(f):>18}{n_:>3}{np:10.0f} {t:<40}{str(args):<30}') # print
save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist
layers.append(m_)
if i == 0:
ch = []
ch.append(c2)
return nn.Sequential(*layers), sorted(save)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--cfg', type=str, default='yolov5s.yaml', help='model.yaml')
parser.add_argument('--batch-size', type=int, default=1, help='total batch size for all GPUs')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--profile', action='store_true', help='profile model speed')
parser.add_argument('--line-profile', action='store_true', help='profile model speed layer by layer')
parser.add_argument('--test', action='store_true', help='test all yolo*.yaml')
opt = parser.parse_args()
opt.cfg = check_yaml(opt.cfg) # check YAML
print_args(vars(opt))
device = select_device(opt.device)
# Create model
im = torch.rand(opt.batch_size, 3, 640, 640).to(device)
model = Model(opt.cfg).to(device)
# Options
if opt.line_profile: # profile layer by layer
model(im, profile=True)
elif opt.profile: # profile forward-backward
results = profile(input=im, ops=[model], n=3)
elif opt.test: # test all models
for cfg in Path(ROOT / 'models').rglob('yolo*.yaml'):
try:
_ = Model(cfg)
except Exception as e:
print(f'Error in {cfg}: {e}')
else: # report fused model summary
model.fuse()
| 16,311 | Python | .py | 311 | 42.954984 | 116 | 0.565921 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,503 | experimental.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/models/experimental.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Experimental modules
"""
import math
import numpy as np
import torch
import torch.nn as nn
from models.common import Conv
from utils.downloads import attempt_download
class Sum(nn.Module):
# Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
def __init__(self, n, weight=False): # n: number of inputs
super().__init__()
self.weight = weight # apply weights boolean
self.iter = range(n - 1) # iter object
if weight:
self.w = nn.Parameter(-torch.arange(1.0, n) / 2, requires_grad=True) # layer weights
def forward(self, x):
y = x[0] # no weight
if self.weight:
w = torch.sigmoid(self.w) * 2
for i in self.iter:
y = y + x[i + 1] * w[i]
else:
for i in self.iter:
y = y + x[i + 1]
return y
class MixConv2d(nn.Module):
# Mixed Depth-wise Conv https://arxiv.org/abs/1907.09595
def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True): # ch_in, ch_out, kernel, stride, ch_strategy
super().__init__()
n = len(k) # number of convolutions
if equal_ch: # equal c_ per group
i = torch.linspace(0, n - 1E-6, c2).floor() # c2 indices
c_ = [(i == g).sum() for g in range(n)] # intermediate channels
else: # equal weight.numel() per group
b = [c2] + [0] * n
a = np.eye(n + 1, n, k=-1)
a -= np.roll(a, 1, axis=1)
a *= np.array(k) ** 2
a[0] = 1
c_ = np.linalg.lstsq(a, b, rcond=None)[0].round() # solve for equal weight indices, ax = b
self.m = nn.ModuleList([
nn.Conv2d(c1, int(c_), k, s, k // 2, groups=math.gcd(c1, int(c_)), bias=False) for k, c_ in zip(k, c_)])
self.bn = nn.BatchNorm2d(c2)
self.act = nn.SiLU()
def forward(self, x):
return self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
class Ensemble(nn.ModuleList):
# Ensemble of models
def __init__(self):
super().__init__()
def forward(self, x, augment=False, profile=False, visualize=False):
y = [module(x, augment, profile, visualize)[0] for module in self]
# y = torch.stack(y).max(0)[0] # max ensemble
# y = torch.stack(y).mean(0) # mean ensemble
y = torch.cat(y, 1) # nms ensemble
return y, None # inference, train output
def attempt_load(weights, device=None, inplace=True, fuse=True):
# Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
from models.yolo import Detect, Model
model = Ensemble()
for w in weights if isinstance(weights, list) else [weights]:
ckpt = torch.load(attempt_download(w), map_location='cpu') # load
ckpt = (ckpt.get('ema') or ckpt['model']).to(device).float() # FP32 model
if not hasattr(ckpt, 'stride'):
ckpt.stride = torch.tensor([32.]) # compatibility update for ResNet etc.
model.append(ckpt.fuse().eval() if fuse and hasattr(ckpt, 'fuse') else ckpt.eval()) # model in eval mode
# Compatibility updates
for m in model.modules():
t = type(m)
if t in (nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU, Detect, Model):
m.inplace = inplace # torch 1.7.0 compatibility
if t is Detect and not isinstance(m.anchor_grid, list):
delattr(m, 'anchor_grid')
setattr(m, 'anchor_grid', [torch.zeros(1)] * m.nl)
elif t is nn.Upsample and not hasattr(m, 'recompute_scale_factor'):
m.recompute_scale_factor = None # torch 1.11.0 compatibility
# Return model
if len(model) == 1:
return model[-1]
# Return detection ensemble
print(f'Ensemble created with {weights}\n')
for k in 'names', 'nc', 'yaml':
setattr(model, k, getattr(model[0], k))
model.stride = model[torch.argmax(torch.tensor([m.stride.max() for m in model])).int()].stride # max stride
assert all(model[0].nc == m.nc for m in model), f'Models have different class counts: {[m.nc for m in model]}'
return model
| 4,194 | Python | .py | 89 | 39.089888 | 116 | 0.591877 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,504 | common.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/models/common.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Common modules
"""
import json
import math
import platform
import warnings
from collections import OrderedDict, namedtuple
from copy import copy
from pathlib import Path
import cv2
import numpy as np
import pandas as pd
import requests
import torch
import torch.nn as nn
from PIL import Image
from torch.cuda import amp
from utils.dataloaders import exif_transpose, letterbox
from utils.general import (LOGGER, ROOT, check_requirements, check_suffix, check_version, colorstr, increment_path,
make_divisible, non_max_suppression, scale_coords, xywh2xyxy, xyxy2xywh, yaml_load)
from utils.plots import Annotator, colors, save_one_box
from utils.torch_utils import copy_attr, smart_inference_mode, time_sync
def autopad(k, p=None): # kernel, padding
# Pad to 'same'
if p is None:
p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
return p
class Conv(nn.Module):
# Standard convolution
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups
super().__init__()
self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
self.bn = nn.BatchNorm2d(c2)
self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def forward_fuse(self, x):
return self.act(self.conv(x))
class DWConv(Conv):
# Depth-wise convolution class
def __init__(self, c1, c2, k=1, s=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups
super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), act=act)
class DWConvTranspose2d(nn.ConvTranspose2d):
# Depth-wise transpose convolution class
def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0): # ch_in, ch_out, kernel, stride, padding, padding_out
super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))
class TransformerLayer(nn.Module):
# Transformer layer https://arxiv.org/abs/2010.11929 (LayerNorm layers removed for better performance)
def __init__(self, c, num_heads):
super().__init__()
self.q = nn.Linear(c, c, bias=False)
self.k = nn.Linear(c, c, bias=False)
self.v = nn.Linear(c, c, bias=False)
self.ma = nn.MultiheadAttention(embed_dim=c, num_heads=num_heads)
self.fc1 = nn.Linear(c, c, bias=False)
self.fc2 = nn.Linear(c, c, bias=False)
def forward(self, x):
x = self.ma(self.q(x), self.k(x), self.v(x))[0] + x
x = self.fc2(self.fc1(x)) + x
return x
class TransformerBlock(nn.Module):
# Vision Transformer https://arxiv.org/abs/2010.11929
def __init__(self, c1, c2, num_heads, num_layers):
super().__init__()
self.conv = None
if c1 != c2:
self.conv = Conv(c1, c2)
self.linear = nn.Linear(c2, c2) # learnable position embedding
self.tr = nn.Sequential(*(TransformerLayer(c2, num_heads) for _ in range(num_layers)))
self.c2 = c2
def forward(self, x):
if self.conv is not None:
x = self.conv(x)
b, _, w, h = x.shape
p = x.flatten(2).permute(2, 0, 1)
return self.tr(p + self.linear(p)).permute(1, 2, 0).reshape(b, self.c2, w, h)
class Bottleneck(nn.Module):
# Standard bottleneck
def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): # ch_in, ch_out, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_, c2, 3, 1, g=g)
self.add = shortcut and c1 == c2
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class BottleneckCSP(nn.Module):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
self.cv4 = Conv(2 * c_, c2, 1, 1)
self.bn = nn.BatchNorm2d(2 * c_) # applied to cat(cv2, cv3)
self.act = nn.SiLU()
self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
def forward(self, x):
y1 = self.cv3(self.m(self.cv1(x)))
y2 = self.cv2(x)
return self.cv4(self.act(self.bn(torch.cat((y1, y2), 1))))
class CrossConv(nn.Module):
# Cross Convolution Downsample
def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
# ch_in, ch_out, kernel, stride, groups, expansion, shortcut
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, (1, k), (1, s))
self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
self.add = shortcut and c1 == c2
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class C3(nn.Module):
# CSP Bottleneck with 3 convolutions
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c1, c_, 1, 1)
self.cv3 = Conv(2 * c_, c2, 1) # optional act=FReLU(c2)
self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
def forward(self, x):
return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))
class C3x(C3):
# C3 module with cross-convolutions
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
super().__init__(c1, c2, n, shortcut, g, e)
c_ = int(c2 * e)
self.m = nn.Sequential(*(CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)))
class C3TR(C3):
# C3 module with TransformerBlock()
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
super().__init__(c1, c2, n, shortcut, g, e)
c_ = int(c2 * e)
self.m = TransformerBlock(c_, c_, 4, n)
class C3SPP(C3):
# C3 module with SPP()
def __init__(self, c1, c2, k=(5, 9, 13), n=1, shortcut=True, g=1, e=0.5):
super().__init__(c1, c2, n, shortcut, g, e)
c_ = int(c2 * e)
self.m = SPP(c_, c_, k)
class C3Ghost(C3):
# C3 module with GhostBottleneck()
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
super().__init__(c1, c2, n, shortcut, g, e)
c_ = int(c2 * e) # hidden channels
self.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n)))
class SPP(nn.Module):
# Spatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729
def __init__(self, c1, c2, k=(5, 9, 13)):
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
def forward(self, x):
x = self.cv1(x)
with warnings.catch_warnings():
warnings.simplefilter('ignore') # suppress torch 1.9.0 max_pool2d() warning
return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))
class SPPF(nn.Module):
# Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
def __init__(self, c1, c2, k=5): # equivalent to SPP(k=(5, 9, 13))
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_ * 4, c2, 1, 1)
self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
def forward(self, x):
x = self.cv1(x)
with warnings.catch_warnings():
warnings.simplefilter('ignore') # suppress torch 1.9.0 max_pool2d() warning
y1 = self.m(x)
y2 = self.m(y1)
return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))
class Focus(nn.Module):
# Focus wh information into c-space
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): # ch_in, ch_out, kernel, stride, padding, groups
super().__init__()
self.conv = Conv(c1 * 4, c2, k, s, p, g, act)
# self.contract = Contract(gain=2)
def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
return self.conv(torch.cat((x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]), 1))
# return self.conv(self.contract(x))
class GhostConv(nn.Module):
# Ghost Convolution https://github.com/huawei-noah/ghostnet
def __init__(self, c1, c2, k=1, s=1, g=1, act=True): # ch_in, ch_out, kernel, stride, groups
super().__init__()
c_ = c2 // 2 # hidden channels
self.cv1 = Conv(c1, c_, k, s, None, g, act)
self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)
def forward(self, x):
y = self.cv1(x)
return torch.cat((y, self.cv2(y)), 1)
class GhostBottleneck(nn.Module):
# Ghost Bottleneck https://github.com/huawei-noah/ghostnet
def __init__(self, c1, c2, k=3, s=1): # ch_in, ch_out, kernel, stride
super().__init__()
c_ = c2 // 2
self.conv = nn.Sequential(
GhostConv(c1, c_, 1, 1), # pw
DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(), # dw
GhostConv(c_, c2, 1, 1, act=False)) # pw-linear
self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False), Conv(c1, c2, 1, 1,
act=False)) if s == 2 else nn.Identity()
def forward(self, x):
return self.conv(x) + self.shortcut(x)
class Contract(nn.Module):
# Contract width-height into channels, i.e. x(1,64,80,80) to x(1,256,40,40)
def __init__(self, gain=2):
super().__init__()
self.gain = gain
def forward(self, x):
b, c, h, w = x.size() # assert (h / s == 0) and (W / s == 0), 'Indivisible gain'
s = self.gain
x = x.view(b, c, h // s, s, w // s, s) # x(1,64,40,2,40,2)
x = x.permute(0, 3, 5, 1, 2, 4).contiguous() # x(1,2,2,64,40,40)
return x.view(b, c * s * s, h // s, w // s) # x(1,256,40,40)
class Expand(nn.Module):
# Expand channels into width-height, i.e. x(1,64,80,80) to x(1,16,160,160)
def __init__(self, gain=2):
super().__init__()
self.gain = gain
def forward(self, x):
b, c, h, w = x.size() # assert C / s ** 2 == 0, 'Indivisible gain'
s = self.gain
x = x.view(b, s, s, c // s ** 2, h, w) # x(1,2,2,16,80,80)
x = x.permute(0, 3, 4, 1, 5, 2).contiguous() # x(1,16,80,2,80,2)
return x.view(b, c // s ** 2, h * s, w * s) # x(1,16,160,160)
class Concat(nn.Module):
# Concatenate a list of tensors along dimension
def __init__(self, dimension=1):
super().__init__()
self.d = dimension
def forward(self, x):
return torch.cat(x, self.d)
class DetectMultiBackend(nn.Module):
# YOLOv5 MultiBackend class for python inference on various backends
def __init__(self, weights='yolov5s.pt', device=torch.device('cpu'), dnn=False, data=None, fp16=False, fuse=True):
# Usage:
# PyTorch: weights = *.pt
# TorchScript: *.torchscript
# ONNX Runtime: *.onnx
# ONNX OpenCV DNN: *.onnx with --dnn
# OpenVINO: *.xml
# CoreML: *.mlmodel
# TensorRT: *.engine
# TensorFlow SavedModel: *_saved_model
# TensorFlow GraphDef: *.pb
# TensorFlow Lite: *.tflite
# TensorFlow Edge TPU: *_edgetpu.tflite
from models.experimental import attempt_download, attempt_load # scoped to avoid circular import
super().__init__()
w = str(weights[0] if isinstance(weights, list) else weights)
pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs = self._model_type(w) # get backend
w = attempt_download(w) # download if not local
fp16 &= pt or jit or onnx or engine # FP16
stride = 32 # default stride
if pt: # PyTorch
model = attempt_load(weights if isinstance(weights, list) else w, device=device, inplace=True, fuse=fuse)
stride = max(int(model.stride.max()), 32) # model stride
names = model.module.names if hasattr(model, 'module') else model.names # get class names
model.half() if fp16 else model.float()
self.model = model # explicitly assign for to(), cpu(), cuda(), half()
elif jit: # TorchScript
LOGGER.info(f'Loading {w} for TorchScript inference...')
extra_files = {'config.txt': ''} # model metadata
model = torch.jit.load(w, _extra_files=extra_files)
model.half() if fp16 else model.float()
if extra_files['config.txt']:
d = json.loads(extra_files['config.txt']) # extra_files dict
stride, names = int(d['stride']), d['names']
elif dnn: # ONNX OpenCV DNN
LOGGER.info(f'Loading {w} for ONNX OpenCV DNN inference...')
check_requirements(('opencv-python>=4.5.4',))
net = cv2.dnn.readNetFromONNX(w)
elif onnx: # ONNX Runtime
LOGGER.info(f'Loading {w} for ONNX Runtime inference...')
cuda = torch.cuda.is_available() and device.type != 'cpu'
check_requirements(('onnx', 'onnxruntime-gpu' if cuda else 'onnxruntime'))
import onnxruntime
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if cuda else ['CPUExecutionProvider']
session = onnxruntime.InferenceSession(w, providers=providers)
meta = session.get_modelmeta().custom_metadata_map # metadata
if 'stride' in meta:
stride, names = int(meta['stride']), eval(meta['names'])
elif xml: # OpenVINO
LOGGER.info(f'Loading {w} for OpenVINO inference...')
check_requirements(('openvino',)) # requires openvino-dev: https://pypi.org/project/openvino-dev/
from openvino.runtime import Core, Layout, get_batch
ie = Core()
if not Path(w).is_file(): # if not *.xml
w = next(Path(w).glob('*.xml')) # get *.xml file from *_openvino_model dir
network = ie.read_model(model=w, weights=Path(w).with_suffix('.bin'))
if network.get_parameters()[0].get_layout().empty:
network.get_parameters()[0].set_layout(Layout("NCHW"))
batch_dim = get_batch(network)
if batch_dim.is_static:
batch_size = batch_dim.get_length()
executable_network = ie.compile_model(network, device_name="CPU") # device_name="MYRIAD" for Intel NCS2
output_layer = next(iter(executable_network.outputs))
meta = Path(w).with_suffix('.yaml')
if meta.exists():
stride, names = self._load_metadata(meta) # load metadata
elif engine: # TensorRT
LOGGER.info(f'Loading {w} for TensorRT inference...')
import tensorrt as trt # https://developer.nvidia.com/nvidia-tensorrt-download
check_version(trt.__version__, '7.0.0', hard=True) # require tensorrt>=7.0.0
if device.type == 'cpu':
device = torch.device('cuda:0')
Binding = namedtuple('Binding', ('name', 'dtype', 'shape', 'data', 'ptr'))
logger = trt.Logger(trt.Logger.INFO)
with open(w, 'rb') as f, trt.Runtime(logger) as runtime:
model = runtime.deserialize_cuda_engine(f.read())
context = model.create_execution_context()
bindings = OrderedDict()
fp16 = False # default updated below
dynamic = False
for index in range(model.num_bindings):
name = model.get_binding_name(index)
dtype = trt.nptype(model.get_binding_dtype(index))
if model.binding_is_input(index):
if -1 in tuple(model.get_binding_shape(index)): # dynamic
dynamic = True
context.set_binding_shape(index, tuple(model.get_profile_shape(0, index)[2]))
if dtype == np.float16:
fp16 = True
shape = tuple(context.get_binding_shape(index))
im = torch.from_numpy(np.empty(shape, dtype=dtype)).to(device)
bindings[name] = Binding(name, dtype, shape, im, int(im.data_ptr()))
binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())
batch_size = bindings['images'].shape[0] # if dynamic, this is instead max batch size
elif coreml: # CoreML
LOGGER.info(f'Loading {w} for CoreML inference...')
import coremltools as ct
model = ct.models.MLModel(w)
else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)
if saved_model: # SavedModel
LOGGER.info(f'Loading {w} for TensorFlow SavedModel inference...')
import tensorflow as tf
keras = False # assume TF1 saved_model
model = tf.keras.models.load_model(w) if keras else tf.saved_model.load(w)
elif pb: # GraphDef https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt
LOGGER.info(f'Loading {w} for TensorFlow GraphDef inference...')
import tensorflow as tf
def wrap_frozen_graph(gd, inputs, outputs):
x = tf.compat.v1.wrap_function(lambda: tf.compat.v1.import_graph_def(gd, name=""), []) # wrapped
ge = x.graph.as_graph_element
return x.prune(tf.nest.map_structure(ge, inputs), tf.nest.map_structure(ge, outputs))
gd = tf.Graph().as_graph_def() # graph_def
with open(w, 'rb') as f:
gd.ParseFromString(f.read())
frozen_func = wrap_frozen_graph(gd, inputs="x:0", outputs="Identity:0")
elif tflite or edgetpu: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python
try: # https://coral.ai/docs/edgetpu/tflite-python/#update-existing-tf-lite-code-for-the-edge-tpu
from tflite_runtime.interpreter import Interpreter, load_delegate
except ImportError:
import tensorflow as tf
Interpreter, load_delegate = tf.lite.Interpreter, tf.lite.experimental.load_delegate,
if edgetpu: # Edge TPU https://coral.ai/software/#edgetpu-runtime
LOGGER.info(f'Loading {w} for TensorFlow Lite Edge TPU inference...')
delegate = {
'Linux': 'libedgetpu.so.1',
'Darwin': 'libedgetpu.1.dylib',
'Windows': 'edgetpu.dll'}[platform.system()]
interpreter = Interpreter(model_path=w, experimental_delegates=[load_delegate(delegate)])
else: # Lite
LOGGER.info(f'Loading {w} for TensorFlow Lite inference...')
interpreter = Interpreter(model_path=w) # load TFLite model
interpreter.allocate_tensors() # allocate
input_details = interpreter.get_input_details() # inputs
output_details = interpreter.get_output_details() # outputs
elif tfjs:
raise NotImplementedError('ERROR: YOLOv5 TF.js inference is not supported')
else:
raise NotImplementedError(f'ERROR: {w} is not a supported format')
# class names
if 'names' not in locals():
names = yaml_load(data)['names'] if data else [f'class{i}' for i in range(999)]
if names[0] == 'n01440764' and len(names) == 1000: # ImageNet
names = yaml_load(ROOT / 'data/ImageNet.yaml')['names'] # human-readable names
self.__dict__.update(locals()) # assign all variables to self
def forward(self, im, augment=False, visualize=False, val=False):
# YOLOv5 MultiBackend inference
b, ch, h, w = im.shape # batch, channel, height, width
if self.fp16 and im.dtype != torch.float16:
im = im.half() # to FP16
if self.pt: # PyTorch
y = self.model(im, augment=augment, visualize=visualize) if augment or visualize else self.model(im)
if isinstance(y, tuple):
y = y[0]
elif self.jit: # TorchScript
y = self.model(im)[0]
elif self.dnn: # ONNX OpenCV DNN
im = im.cpu().numpy() # torch to numpy
self.net.setInput(im)
y = self.net.forward()
elif self.onnx: # ONNX Runtime
im = im.cpu().numpy() # torch to numpy
y = self.session.run([self.session.get_outputs()[0].name], {self.session.get_inputs()[0].name: im})[0]
elif self.xml: # OpenVINO
im = im.cpu().numpy() # FP32
y = self.executable_network([im])[self.output_layer]
elif self.engine: # TensorRT
if self.dynamic and im.shape != self.bindings['images'].shape:
i_in, i_out = (self.model.get_binding_index(x) for x in ('images', 'output'))
self.context.set_binding_shape(i_in, im.shape) # reshape if dynamic
self.bindings['images'] = self.bindings['images']._replace(shape=im.shape)
self.bindings['output'].data.resize_(tuple(self.context.get_binding_shape(i_out)))
s = self.bindings['images'].shape
assert im.shape == s, f"input size {im.shape} {'>' if self.dynamic else 'not equal to'} max model size {s}"
self.binding_addrs['images'] = int(im.data_ptr())
self.context.execute_v2(list(self.binding_addrs.values()))
y = self.bindings['output'].data
elif self.coreml: # CoreML
im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)
im = Image.fromarray((im[0] * 255).astype('uint8'))
# im = im.resize((192, 320), Image.ANTIALIAS)
y = self.model.predict({'image': im}) # coordinates are xywh normalized
if 'confidence' in y:
box = xywh2xyxy(y['coordinates'] * [[w, h, w, h]]) # xyxy pixels
conf, cls = y['confidence'].max(1), y['confidence'].argmax(1).astype(np.float)
y = np.concatenate((box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1)
else:
k = 'var_' + str(sorted(int(k.replace('var_', '')) for k in y)[-1]) # output key
y = y[k] # output
else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)
im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)
if self.saved_model: # SavedModel
y = (self.model(im, training=False) if self.keras else self.model(im)).numpy()
elif self.pb: # GraphDef
y = self.frozen_func(x=self.tf.constant(im)).numpy()
else: # Lite or Edge TPU
input, output = self.input_details[0], self.output_details[0]
int8 = input['dtype'] == np.uint8 # is TFLite quantized uint8 model
if int8:
scale, zero_point = input['quantization']
im = (im / scale + zero_point).astype(np.uint8) # de-scale
self.interpreter.set_tensor(input['index'], im)
self.interpreter.invoke()
y = self.interpreter.get_tensor(output['index'])
if int8:
scale, zero_point = output['quantization']
y = (y.astype(np.float32) - zero_point) * scale # re-scale
y[..., :4] *= [w, h, w, h] # xywh normalized to pixels
if isinstance(y, np.ndarray):
y = torch.tensor(y, device=self.device)
return (y, []) if val else y
def warmup(self, imgsz=(1, 3, 640, 640)):
# Warmup model by running inference once
warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb
if any(warmup_types) and self.device.type != 'cpu':
im = torch.zeros(*imgsz, dtype=torch.half if self.fp16 else torch.float, device=self.device) # input
for _ in range(2 if self.jit else 1): #
self.forward(im) # warmup
@staticmethod
def _model_type(p='path/to/model.pt'):
# Return model type from model path, i.e. path='path/to/model.onnx' -> type=onnx
from export import export_formats
suffixes = list(export_formats().Suffix) + ['.xml'] # export suffixes
check_suffix(p, suffixes) # checks
p = Path(p).name # eliminate trailing separators
pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, xml2 = (s in p for s in suffixes)
xml |= xml2 # *_openvino_model or *.xml
tflite &= not edgetpu # *.tflite
return pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs
@staticmethod
def _load_metadata(f='path/to/meta.yaml'):
# Load metadata from meta.yaml if it exists
d = yaml_load(f)
return d['stride'], d['names'] # assign stride, names
class AutoShape(nn.Module):
# YOLOv5 input-robust model wrapper for passing cv2/np/PIL/torch inputs. Includes preprocessing, inference and NMS
conf = 0.25 # NMS confidence threshold
iou = 0.45 # NMS IoU threshold
agnostic = False # NMS class-agnostic
multi_label = False # NMS multiple labels per box
classes = None # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
max_det = 1000 # maximum number of detections per image
amp = False # Automatic Mixed Precision (AMP) inference
def __init__(self, model, verbose=True):
super().__init__()
if verbose:
LOGGER.info('Adding AutoShape... ')
copy_attr(self, model, include=('yaml', 'nc', 'hyp', 'names', 'stride', 'abc'), exclude=()) # copy attributes
self.dmb = isinstance(model, DetectMultiBackend) # DetectMultiBackend() instance
self.pt = not self.dmb or model.pt # PyTorch model
self.model = model.eval()
if self.pt:
m = self.model.model.model[-1] if self.dmb else self.model.model[-1] # Detect()
m.inplace = False # Detect.inplace=False for safe multithread inference
def _apply(self, fn):
# Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffers
self = super()._apply(fn)
if self.pt:
m = self.model.model.model[-1] if self.dmb else self.model.model[-1] # Detect()
m.stride = fn(m.stride)
m.grid = list(map(fn, m.grid))
if isinstance(m.anchor_grid, list):
m.anchor_grid = list(map(fn, m.anchor_grid))
return self
@smart_inference_mode()
def forward(self, imgs, size=640, augment=False, profile=False):
# Inference from various sources. For height=640, width=1280, RGB images example inputs are:
# file: imgs = 'data/images/zidane.jpg' # str or PosixPath
# URI: = 'https://ultralytics.com/images/zidane.jpg'
# OpenCV: = cv2.imread('image.jpg')[:,:,::-1] # HWC BGR to RGB x(640,1280,3)
# PIL: = Image.open('image.jpg') or ImageGrab.grab() # HWC x(640,1280,3)
# numpy: = np.zeros((640,1280,3)) # HWC
# torch: = torch.zeros(16,3,320,640) # BCHW (scaled to size=640, 0-1 values)
# multiple: = [Image.open('image1.jpg'), Image.open('image2.jpg'), ...] # list of images
t = [time_sync()]
p = next(self.model.parameters()) if self.pt else torch.zeros(1, device=self.model.device) # for device, type
autocast = self.amp and (p.device.type != 'cpu') # Automatic Mixed Precision (AMP) inference
if isinstance(imgs, torch.Tensor): # torch
with amp.autocast(autocast):
return self.model(imgs.to(p.device).type_as(p), augment, profile) # inference
# Pre-process
n, imgs = (len(imgs), list(imgs)) if isinstance(imgs, (list, tuple)) else (1, [imgs]) # number, list of images
shape0, shape1, files = [], [], [] # image and inference shapes, filenames
for i, im in enumerate(imgs):
f = f'image{i}' # filename
if isinstance(im, (str, Path)): # filename or uri
im, f = Image.open(requests.get(im, stream=True).raw if str(im).startswith('http') else im), im
im = np.asarray(exif_transpose(im))
elif isinstance(im, Image.Image): # PIL Image
im, f = np.asarray(exif_transpose(im)), getattr(im, 'filename', f) or f
files.append(Path(f).with_suffix('.jpg').name)
if im.shape[0] < 5: # image in CHW
im = im.transpose((1, 2, 0)) # reverse dataloader .transpose(2, 0, 1)
im = im[..., :3] if im.ndim == 3 else np.tile(im[..., None], 3) # enforce 3ch input
s = im.shape[:2] # HWC
shape0.append(s) # image shape
g = (size / max(s)) # gain
shape1.append([y * g for y in s])
imgs[i] = im if im.data.contiguous else np.ascontiguousarray(im) # update
shape1 = [make_divisible(x, self.stride) if self.pt else size for x in np.array(shape1).max(0)] # inf shape
x = [letterbox(im, shape1, auto=False)[0] for im in imgs] # pad
x = np.ascontiguousarray(np.array(x).transpose((0, 3, 1, 2))) # stack and BHWC to BCHW
x = torch.from_numpy(x).to(p.device).type_as(p) / 255 # uint8 to fp16/32
t.append(time_sync())
with amp.autocast(autocast):
# Inference
y = self.model(x, augment, profile) # forward
t.append(time_sync())
# Post-process
y = non_max_suppression(y if self.dmb else y[0],
self.conf,
self.iou,
self.classes,
self.agnostic,
self.multi_label,
max_det=self.max_det) # NMS
for i in range(n):
scale_coords(shape1, y[i][:, :4], shape0[i])
t.append(time_sync())
return Detections(imgs, y, files, t, self.names, x.shape)
class Detections:
# YOLOv5 detections class for inference results
def __init__(self, imgs, pred, files, times=(0, 0, 0, 0), names=None, shape=None):
super().__init__()
d = pred[0].device # device
gn = [torch.tensor([*(im.shape[i] for i in [1, 0, 1, 0]), 1, 1], device=d) for im in imgs] # normalizations
self.imgs = imgs # list of images as numpy arrays
self.pred = pred # list of tensors pred[0] = (xyxy, conf, cls)
self.names = names # class names
self.files = files # image filenames
self.times = times # profiling times
self.xyxy = pred # xyxy pixels
self.xywh = [xyxy2xywh(x) for x in pred] # xywh pixels
self.xyxyn = [x / g for x, g in zip(self.xyxy, gn)] # xyxy normalized
self.xywhn = [x / g for x, g in zip(self.xywh, gn)] # xywh normalized
self.n = len(self.pred) # number of images (batch size)
self.t = tuple((times[i + 1] - times[i]) * 1000 / self.n for i in range(3)) # timestamps (ms)
self.s = shape # inference BCHW shape
def display(self, pprint=False, show=False, save=False, crop=False, render=False, labels=True, save_dir=Path('')):
crops = []
for i, (im, pred) in enumerate(zip(self.imgs, self.pred)):
s = f'image {i + 1}/{len(self.pred)}: {im.shape[0]}x{im.shape[1]} ' # string
if pred.shape[0]:
for c in pred[:, -1].unique():
n = (pred[:, -1] == c).sum() # detections per class
s += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " # add to string
if show or save or render or crop:
annotator = Annotator(im, example=str(self.names))
for *box, conf, cls in reversed(pred): # xyxy, confidence, class
label = f'{self.names[int(cls)]} {conf:.2f}'
if crop:
file = save_dir / 'crops' / self.names[int(cls)] / self.files[i] if save else None
crops.append({
'box': box,
'conf': conf,
'cls': cls,
'label': label,
'im': save_one_box(box, im, file=file, save=save)})
else: # all others
annotator.box_label(box, label if labels else '', color=colors(cls))
im = annotator.im
else:
s += '(no detections)'
im = Image.fromarray(im.astype(np.uint8)) if isinstance(im, np.ndarray) else im # from np
if pprint:
print(s.rstrip(', '))
if show:
im.show(self.files[i]) # show
if save:
f = self.files[i]
im.save(save_dir / f) # save
if i == self.n - 1:
LOGGER.info(f"Saved {self.n} image{'s' * (self.n > 1)} to {colorstr('bold', save_dir)}")
if render:
self.imgs[i] = np.asarray(im)
if crop:
if save:
LOGGER.info(f'Saved results to {save_dir}\n')
return crops
def print(self):
self.display(pprint=True) # print results
print(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {tuple(self.s)}' % self.t)
def show(self, labels=True):
self.display(show=True, labels=labels) # show results
def save(self, labels=True, save_dir='runs/detect/exp'):
save_dir = increment_path(save_dir, exist_ok=save_dir != 'runs/detect/exp', mkdir=True) # increment save_dir
self.display(save=True, labels=labels, save_dir=save_dir) # save results
def crop(self, save=True, save_dir='runs/detect/exp'):
save_dir = increment_path(save_dir, exist_ok=save_dir != 'runs/detect/exp', mkdir=True) if save else None
return self.display(crop=True, save=save, save_dir=save_dir) # crop results
def render(self, labels=True):
self.display(render=True, labels=labels) # render results
return self.imgs
def pandas(self):
# return detections as pandas DataFrames, i.e. print(results.pandas().xyxy[0])
new = copy(self) # return copy
ca = 'xmin', 'ymin', 'xmax', 'ymax', 'confidence', 'class', 'name' # xyxy columns
cb = 'xcenter', 'ycenter', 'width', 'height', 'confidence', 'class', 'name' # xywh columns
for k, c in zip(['xyxy', 'xyxyn', 'xywh', 'xywhn'], [ca, ca, cb, cb]):
a = [[x[:5] + [int(x[5]), self.names[int(x[5])]] for x in x.tolist()] for x in getattr(self, k)] # update
setattr(new, k, [pd.DataFrame(x, columns=c) for x in a])
return new
def tolist(self):
# return a list of Detections objects, i.e. 'for result in results.tolist():'
r = range(self.n) # iterable
x = [Detections([self.imgs[i]], [self.pred[i]], [self.files[i]], self.times, self.names, self.s) for i in r]
# for d in x:
# for k in ['imgs', 'pred', 'xyxy', 'xyxyn', 'xywh', 'xywhn']:
# setattr(d, k, getattr(d, k)[0]) # pop out of list
return x
def __len__(self):
return self.n # override len(results)
def __str__(self):
self.print() # override print(results)
return ''
class Classify(nn.Module):
# Classification head, i.e. x(b,c1,20,20) to x(b,c2)
def __init__(self, c1, c2, k=1, s=1, p=None, g=1): # ch_in, ch_out, kernel, stride, padding, groups
super().__init__()
c_ = 1280 # efficientnet_b0 size
self.conv = Conv(c1, c_, k, s, autopad(k, p), g)
self.pool = nn.AdaptiveAvgPool2d(1) # to x(b,c_,1,1)
self.drop = nn.Dropout(p=0.0, inplace=True)
self.linear = nn.Linear(c_, c2) # to x(b,c2)
def forward(self, x):
if isinstance(x, list):
x = torch.cat(x, 1)
return self.linear(self.drop(self.pool(self.conv(x)).flatten(1)))
| 37,243 | Python | .py | 668 | 44.773952 | 119 | 0.563419 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,505 | tf.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/models/tf.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
TensorFlow, Keras and TFLite versions of YOLOv5
Authored by https://github.com/zldrobit in PR https://github.com/ultralytics/yolov5/pull/1127
Usage:
$ python models/tf.py --weights yolov5s.pt
Export:
$ python path/to/export.py --weights yolov5s.pt --include saved_model pb tflite tfjs
"""
import argparse
import sys
from copy import deepcopy
from pathlib import Path
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
# ROOT = ROOT.relative_to(Path.cwd()) # relative
import numpy as np
import tensorflow as tf
import torch
import torch.nn as nn
from tensorflow import keras
from models.common import (C3, SPP, SPPF, Bottleneck, BottleneckCSP, C3x, Concat, Conv, CrossConv, DWConv,
DWConvTranspose2d, Focus, autopad)
from models.experimental import MixConv2d, attempt_load
from models.yolo import Detect
from utils.activations import SiLU
from utils.general import LOGGER, make_divisible, print_args
class TFBN(keras.layers.Layer):
# TensorFlow BatchNormalization wrapper
def __init__(self, w=None):
super().__init__()
self.bn = keras.layers.BatchNormalization(
beta_initializer=keras.initializers.Constant(w.bias.numpy()),
gamma_initializer=keras.initializers.Constant(w.weight.numpy()),
moving_mean_initializer=keras.initializers.Constant(w.running_mean.numpy()),
moving_variance_initializer=keras.initializers.Constant(w.running_var.numpy()),
epsilon=w.eps)
def call(self, inputs):
return self.bn(inputs)
class TFPad(keras.layers.Layer):
# Pad inputs in spatial dimensions 1 and 2
def __init__(self, pad):
super().__init__()
if isinstance(pad, int):
self.pad = tf.constant([[0, 0], [pad, pad], [pad, pad], [0, 0]])
else: # tuple/list
self.pad = tf.constant([[0, 0], [pad[0], pad[0]], [pad[1], pad[1]], [0, 0]])
def call(self, inputs):
return tf.pad(inputs, self.pad, mode='constant', constant_values=0)
class TFConv(keras.layers.Layer):
# Standard convolution
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True, w=None):
# ch_in, ch_out, weights, kernel, stride, padding, groups
super().__init__()
assert g == 1, "TF v2.2 Conv2D does not support 'groups' argument"
# TensorFlow convolution padding is inconsistent with PyTorch (e.g. k=3 s=2 'SAME' padding)
# see https://stackoverflow.com/questions/52975843/comparing-conv2d-with-padding-between-tensorflow-and-pytorch
conv = keras.layers.Conv2D(
filters=c2,
kernel_size=k,
strides=s,
padding='SAME' if s == 1 else 'VALID',
use_bias=not hasattr(w, 'bn'),
kernel_initializer=keras.initializers.Constant(w.conv.weight.permute(2, 3, 1, 0).numpy()),
bias_initializer='zeros' if hasattr(w, 'bn') else keras.initializers.Constant(w.conv.bias.numpy()))
self.conv = conv if s == 1 else keras.Sequential([TFPad(autopad(k, p)), conv])
self.bn = TFBN(w.bn) if hasattr(w, 'bn') else tf.identity
self.act = activations(w.act) if act else tf.identity
def call(self, inputs):
return self.act(self.bn(self.conv(inputs)))
class TFDWConv(keras.layers.Layer):
# Depthwise convolution
def __init__(self, c1, c2, k=1, s=1, p=None, act=True, w=None):
# ch_in, ch_out, weights, kernel, stride, padding, groups
super().__init__()
assert c2 % c1 == 0, f'TFDWConv() output={c2} must be a multiple of input={c1} channels'
conv = keras.layers.DepthwiseConv2D(
kernel_size=k,
depth_multiplier=c2 // c1,
strides=s,
padding='SAME' if s == 1 else 'VALID',
use_bias=not hasattr(w, 'bn'),
depthwise_initializer=keras.initializers.Constant(w.conv.weight.permute(2, 3, 1, 0).numpy()),
bias_initializer='zeros' if hasattr(w, 'bn') else keras.initializers.Constant(w.conv.bias.numpy()))
self.conv = conv if s == 1 else keras.Sequential([TFPad(autopad(k, p)), conv])
self.bn = TFBN(w.bn) if hasattr(w, 'bn') else tf.identity
self.act = activations(w.act) if act else tf.identity
def call(self, inputs):
return self.act(self.bn(self.conv(inputs)))
class TFDWConvTranspose2d(keras.layers.Layer):
# Depthwise ConvTranspose2d
def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0, w=None):
# ch_in, ch_out, weights, kernel, stride, padding, groups
super().__init__()
assert c1 == c2, f'TFDWConv() output={c2} must be equal to input={c1} channels'
assert k == 4 and p1 == 1, 'TFDWConv() only valid for k=4 and p1=1'
weight, bias = w.weight.permute(2, 3, 1, 0).numpy(), w.bias.numpy()
self.c1 = c1
self.conv = [
keras.layers.Conv2DTranspose(filters=1,
kernel_size=k,
strides=s,
padding='VALID',
output_padding=p2,
use_bias=True,
kernel_initializer=keras.initializers.Constant(weight[..., i:i + 1]),
bias_initializer=keras.initializers.Constant(bias[i])) for i in range(c1)]
def call(self, inputs):
return tf.concat([m(x) for m, x in zip(self.conv, tf.split(inputs, self.c1, 3))], 3)[:, 1:-1, 1:-1]
class TFFocus(keras.layers.Layer):
# Focus wh information into c-space
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True, w=None):
# ch_in, ch_out, kernel, stride, padding, groups
super().__init__()
self.conv = TFConv(c1 * 4, c2, k, s, p, g, act, w.conv)
def call(self, inputs): # x(b,w,h,c) -> y(b,w/2,h/2,4c)
# inputs = inputs / 255 # normalize 0-255 to 0-1
inputs = [inputs[:, ::2, ::2, :], inputs[:, 1::2, ::2, :], inputs[:, ::2, 1::2, :], inputs[:, 1::2, 1::2, :]]
return self.conv(tf.concat(inputs, 3))
class TFBottleneck(keras.layers.Layer):
# Standard bottleneck
def __init__(self, c1, c2, shortcut=True, g=1, e=0.5, w=None): # ch_in, ch_out, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv(c_, c2, 3, 1, g=g, w=w.cv2)
self.add = shortcut and c1 == c2
def call(self, inputs):
return inputs + self.cv2(self.cv1(inputs)) if self.add else self.cv2(self.cv1(inputs))
class TFCrossConv(keras.layers.Layer):
# Cross Convolution
def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False, w=None):
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = TFConv(c1, c_, (1, k), (1, s), w=w.cv1)
self.cv2 = TFConv(c_, c2, (k, 1), (s, 1), g=g, w=w.cv2)
self.add = shortcut and c1 == c2
def call(self, inputs):
return inputs + self.cv2(self.cv1(inputs)) if self.add else self.cv2(self.cv1(inputs))
class TFConv2d(keras.layers.Layer):
# Substitution for PyTorch nn.Conv2D
def __init__(self, c1, c2, k, s=1, g=1, bias=True, w=None):
super().__init__()
assert g == 1, "TF v2.2 Conv2D does not support 'groups' argument"
self.conv = keras.layers.Conv2D(filters=c2,
kernel_size=k,
strides=s,
padding='VALID',
use_bias=bias,
kernel_initializer=keras.initializers.Constant(
w.weight.permute(2, 3, 1, 0).numpy()),
bias_initializer=keras.initializers.Constant(w.bias.numpy()) if bias else None)
def call(self, inputs):
return self.conv(inputs)
class TFBottleneckCSP(keras.layers.Layer):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, w=None):
# ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv2d(c1, c_, 1, 1, bias=False, w=w.cv2)
self.cv3 = TFConv2d(c_, c_, 1, 1, bias=False, w=w.cv3)
self.cv4 = TFConv(2 * c_, c2, 1, 1, w=w.cv4)
self.bn = TFBN(w.bn)
self.act = lambda x: keras.activations.swish(x)
self.m = keras.Sequential([TFBottleneck(c_, c_, shortcut, g, e=1.0, w=w.m[j]) for j in range(n)])
def call(self, inputs):
y1 = self.cv3(self.m(self.cv1(inputs)))
y2 = self.cv2(inputs)
return self.cv4(self.act(self.bn(tf.concat((y1, y2), axis=3))))
class TFC3(keras.layers.Layer):
# CSP Bottleneck with 3 convolutions
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, w=None):
# ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv(c1, c_, 1, 1, w=w.cv2)
self.cv3 = TFConv(2 * c_, c2, 1, 1, w=w.cv3)
self.m = keras.Sequential([TFBottleneck(c_, c_, shortcut, g, e=1.0, w=w.m[j]) for j in range(n)])
def call(self, inputs):
return self.cv3(tf.concat((self.m(self.cv1(inputs)), self.cv2(inputs)), axis=3))
class TFC3x(keras.layers.Layer):
# 3 module with cross-convolutions
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, w=None):
# ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
c_ = int(c2 * e) # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv(c1, c_, 1, 1, w=w.cv2)
self.cv3 = TFConv(2 * c_, c2, 1, 1, w=w.cv3)
self.m = keras.Sequential([
TFCrossConv(c_, c_, k=3, s=1, g=g, e=1.0, shortcut=shortcut, w=w.m[j]) for j in range(n)])
def call(self, inputs):
return self.cv3(tf.concat((self.m(self.cv1(inputs)), self.cv2(inputs)), axis=3))
class TFSPP(keras.layers.Layer):
# Spatial pyramid pooling layer used in YOLOv3-SPP
def __init__(self, c1, c2, k=(5, 9, 13), w=None):
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv(c_ * (len(k) + 1), c2, 1, 1, w=w.cv2)
self.m = [keras.layers.MaxPool2D(pool_size=x, strides=1, padding='SAME') for x in k]
def call(self, inputs):
x = self.cv1(inputs)
return self.cv2(tf.concat([x] + [m(x) for m in self.m], 3))
class TFSPPF(keras.layers.Layer):
# Spatial pyramid pooling-Fast layer
def __init__(self, c1, c2, k=5, w=None):
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = TFConv(c1, c_, 1, 1, w=w.cv1)
self.cv2 = TFConv(c_ * 4, c2, 1, 1, w=w.cv2)
self.m = keras.layers.MaxPool2D(pool_size=k, strides=1, padding='SAME')
def call(self, inputs):
x = self.cv1(inputs)
y1 = self.m(x)
y2 = self.m(y1)
return self.cv2(tf.concat([x, y1, y2, self.m(y2)], 3))
class TFDetect(keras.layers.Layer):
# TF YOLOv5 Detect layer
def __init__(self, nc=80, anchors=(), ch=(), imgsz=(640, 640), w=None): # detection layer
super().__init__()
self.stride = tf.convert_to_tensor(w.stride.numpy(), dtype=tf.float32)
self.nc = nc # number of classes
self.no = nc + 5 # number of outputs per anchor
self.nl = len(anchors) # number of detection layers
self.na = len(anchors[0]) // 2 # number of anchors
self.grid = [tf.zeros(1)] * self.nl # init grid
self.anchors = tf.convert_to_tensor(w.anchors.numpy(), dtype=tf.float32)
self.anchor_grid = tf.reshape(self.anchors * tf.reshape(self.stride, [self.nl, 1, 1]), [self.nl, 1, -1, 1, 2])
self.m = [TFConv2d(x, self.no * self.na, 1, w=w.m[i]) for i, x in enumerate(ch)]
self.training = False # set to False after building model
self.imgsz = imgsz
for i in range(self.nl):
ny, nx = self.imgsz[0] // self.stride[i], self.imgsz[1] // self.stride[i]
self.grid[i] = self._make_grid(nx, ny)
def call(self, inputs):
z = [] # inference output
x = []
for i in range(self.nl):
x.append(self.m[i](inputs[i]))
# x(bs,20,20,255) to x(bs,3,20,20,85)
ny, nx = self.imgsz[0] // self.stride[i], self.imgsz[1] // self.stride[i]
x[i] = tf.reshape(x[i], [-1, ny * nx, self.na, self.no])
if not self.training: # inference
y = tf.sigmoid(x[i])
grid = tf.transpose(self.grid[i], [0, 2, 1, 3]) - 0.5
anchor_grid = tf.transpose(self.anchor_grid[i], [0, 2, 1, 3]) * 4
xy = (y[..., 0:2] * 2 + grid) * self.stride[i] # xy
wh = y[..., 2:4] ** 2 * anchor_grid
# Normalize xywh to 0-1 to reduce calibration error
xy /= tf.constant([[self.imgsz[1], self.imgsz[0]]], dtype=tf.float32)
wh /= tf.constant([[self.imgsz[1], self.imgsz[0]]], dtype=tf.float32)
y = tf.concat([xy, wh, y[..., 4:]], -1)
z.append(tf.reshape(y, [-1, self.na * ny * nx, self.no]))
return tf.transpose(x, [0, 2, 1, 3]) if self.training else (tf.concat(z, 1), x)
@staticmethod
def _make_grid(nx=20, ny=20):
# yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])
# return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()
xv, yv = tf.meshgrid(tf.range(nx), tf.range(ny))
return tf.cast(tf.reshape(tf.stack([xv, yv], 2), [1, 1, ny * nx, 2]), dtype=tf.float32)
class TFUpsample(keras.layers.Layer):
# TF version of torch.nn.Upsample()
def __init__(self, size, scale_factor, mode, w=None): # warning: all arguments needed including 'w'
super().__init__()
assert scale_factor == 2, "scale_factor must be 2"
self.upsample = lambda x: tf.image.resize(x, (x.shape[1] * 2, x.shape[2] * 2), method=mode)
# self.upsample = keras.layers.UpSampling2D(size=scale_factor, interpolation=mode)
# with default arguments: align_corners=False, half_pixel_centers=False
# self.upsample = lambda x: tf.raw_ops.ResizeNearestNeighbor(images=x,
# size=(x.shape[1] * 2, x.shape[2] * 2))
def call(self, inputs):
return self.upsample(inputs)
class TFConcat(keras.layers.Layer):
# TF version of torch.concat()
def __init__(self, dimension=1, w=None):
super().__init__()
assert dimension == 1, "convert only NCHW to NHWC concat"
self.d = 3
def call(self, inputs):
return tf.concat(inputs, self.d)
def parse_model(d, ch, model, imgsz): # model_dict, input_channels(3)
LOGGER.info(f"\n{'':>3}{'from':>18}{'n':>3}{'params':>10} {'module':<40}{'arguments':<30}")
anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchors
no = na * (nc + 5) # number of outputs = anchors * (classes + 5)
layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out
for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, args
m_str = m
m = eval(m) if isinstance(m, str) else m # eval strings
for j, a in enumerate(args):
try:
args[j] = eval(a) if isinstance(a, str) else a # eval strings
except NameError:
pass
n = max(round(n * gd), 1) if n > 1 else n # depth gain
if m in [
nn.Conv2d, Conv, DWConv, DWConvTranspose2d, Bottleneck, SPP, SPPF, MixConv2d, Focus, CrossConv,
BottleneckCSP, C3, C3x]:
c1, c2 = ch[f], args[0]
c2 = make_divisible(c2 * gw, 8) if c2 != no else c2
args = [c1, c2, *args[1:]]
if m in [BottleneckCSP, C3, C3x]:
args.insert(2, n)
n = 1
elif m is nn.BatchNorm2d:
args = [ch[f]]
elif m is Concat:
c2 = sum(ch[-1 if x == -1 else x + 1] for x in f)
elif m is Detect:
args.append([ch[x + 1] for x in f])
if isinstance(args[1], int): # number of anchors
args[1] = [list(range(args[1] * 2))] * len(f)
args.append(imgsz)
else:
c2 = ch[f]
tf_m = eval('TF' + m_str.replace('nn.', ''))
m_ = keras.Sequential([tf_m(*args, w=model.model[i][j]) for j in range(n)]) if n > 1 \
else tf_m(*args, w=model.model[i]) # module
torch_m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args) # module
t = str(m)[8:-2].replace('__main__.', '') # module type
np = sum(x.numel() for x in torch_m_.parameters()) # number params
m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params
LOGGER.info(f'{i:>3}{str(f):>18}{str(n):>3}{np:>10} {t:<40}{str(args):<30}') # print
save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist
layers.append(m_)
ch.append(c2)
return keras.Sequential(layers), sorted(save)
class TFModel:
# TF YOLOv5 model
def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, model=None, imgsz=(640, 640)): # model, channels, classes
super().__init__()
if isinstance(cfg, dict):
self.yaml = cfg # model dict
else: # is *.yaml
import yaml # for torch hub
self.yaml_file = Path(cfg).name
with open(cfg) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader) # model dict
# Define model
if nc and nc != self.yaml['nc']:
LOGGER.info(f"Overriding {cfg} nc={self.yaml['nc']} with nc={nc}")
self.yaml['nc'] = nc # override yaml value
self.model, self.savelist = parse_model(deepcopy(self.yaml), ch=[ch], model=model, imgsz=imgsz)
def predict(self,
inputs,
tf_nms=False,
agnostic_nms=False,
topk_per_class=100,
topk_all=100,
iou_thres=0.45,
conf_thres=0.25):
y = [] # outputs
x = inputs
for m in self.model.layers:
if m.f != -1: # if not from previous layer
x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layers
x = m(x) # run
y.append(x if m.i in self.savelist else None) # save output
# Add TensorFlow NMS
if tf_nms:
boxes = self._xywh2xyxy(x[0][..., :4])
probs = x[0][:, :, 4:5]
classes = x[0][:, :, 5:]
scores = probs * classes
if agnostic_nms:
nms = AgnosticNMS()((boxes, classes, scores), topk_all, iou_thres, conf_thres)
else:
boxes = tf.expand_dims(boxes, 2)
nms = tf.image.combined_non_max_suppression(boxes,
scores,
topk_per_class,
topk_all,
iou_thres,
conf_thres,
clip_boxes=False)
return nms, x[1]
return x[0] # output only first tensor [1,6300,85] = [xywh, conf, class0, class1, ...]
# x = x[0][0] # [x(1,6300,85), ...] to x(6300,85)
# xywh = x[..., :4] # x(6300,4) boxes
# conf = x[..., 4:5] # x(6300,1) confidences
# cls = tf.reshape(tf.cast(tf.argmax(x[..., 5:], axis=1), tf.float32), (-1, 1)) # x(6300,1) classes
# return tf.concat([conf, cls, xywh], 1)
@staticmethod
def _xywh2xyxy(xywh):
# Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right
x, y, w, h = tf.split(xywh, num_or_size_splits=4, axis=-1)
return tf.concat([x - w / 2, y - h / 2, x + w / 2, y + h / 2], axis=-1)
class AgnosticNMS(keras.layers.Layer):
# TF Agnostic NMS
def call(self, input, topk_all, iou_thres, conf_thres):
# wrap map_fn to avoid TypeSpec related error https://stackoverflow.com/a/65809989/3036450
return tf.map_fn(lambda x: self._nms(x, topk_all, iou_thres, conf_thres),
input,
fn_output_signature=(tf.float32, tf.float32, tf.float32, tf.int32),
name='agnostic_nms')
@staticmethod
def _nms(x, topk_all=100, iou_thres=0.45, conf_thres=0.25): # agnostic NMS
boxes, classes, scores = x
class_inds = tf.cast(tf.argmax(classes, axis=-1), tf.float32)
scores_inp = tf.reduce_max(scores, -1)
selected_inds = tf.image.non_max_suppression(boxes,
scores_inp,
max_output_size=topk_all,
iou_threshold=iou_thres,
score_threshold=conf_thres)
selected_boxes = tf.gather(boxes, selected_inds)
padded_boxes = tf.pad(selected_boxes,
paddings=[[0, topk_all - tf.shape(selected_boxes)[0]], [0, 0]],
mode="CONSTANT",
constant_values=0.0)
selected_scores = tf.gather(scores_inp, selected_inds)
padded_scores = tf.pad(selected_scores,
paddings=[[0, topk_all - tf.shape(selected_boxes)[0]]],
mode="CONSTANT",
constant_values=-1.0)
selected_classes = tf.gather(class_inds, selected_inds)
padded_classes = tf.pad(selected_classes,
paddings=[[0, topk_all - tf.shape(selected_boxes)[0]]],
mode="CONSTANT",
constant_values=-1.0)
valid_detections = tf.shape(selected_inds)[0]
return padded_boxes, padded_scores, padded_classes, valid_detections
def activations(act=nn.SiLU):
# Returns TF activation from input PyTorch activation
if isinstance(act, nn.LeakyReLU):
return lambda x: keras.activations.relu(x, alpha=0.1)
elif isinstance(act, nn.Hardswish):
return lambda x: x * tf.nn.relu6(x + 3) * 0.166666667
elif isinstance(act, (nn.SiLU, SiLU)):
return lambda x: keras.activations.swish(x)
else:
raise Exception(f'no matching TensorFlow activation found for PyTorch activation {act}')
def representative_dataset_gen(dataset, ncalib=100):
# Representative dataset generator for use with converter.representative_dataset, returns a generator of np arrays
for n, (path, img, im0s, vid_cap, string) in enumerate(dataset):
im = np.transpose(img, [1, 2, 0])
im = np.expand_dims(im, axis=0).astype(np.float32)
im /= 255
yield [im]
if n >= ncalib:
break
def run(
weights=ROOT / 'yolov5s.pt', # weights path
imgsz=(640, 640), # inference size h,w
batch_size=1, # batch size
dynamic=False, # dynamic batch size
):
# PyTorch model
im = torch.zeros((batch_size, 3, *imgsz)) # BCHW image
model = attempt_load(weights, device=torch.device('cpu'), inplace=True, fuse=False)
_ = model(im) # inference
model.info()
# TensorFlow model
im = tf.zeros((batch_size, *imgsz, 3)) # BHWC image
tf_model = TFModel(cfg=model.yaml, model=model, nc=model.nc, imgsz=imgsz)
_ = tf_model.predict(im) # inference
# Keras model
im = keras.Input(shape=(*imgsz, 3), batch_size=None if dynamic else batch_size)
keras_model = keras.Model(inputs=im, outputs=tf_model.predict(im))
keras_model.summary()
LOGGER.info('PyTorch, TensorFlow and Keras models successfully verified.\nUse export.py for TF model export.')
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='weights path')
parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[640], help='inference size h,w')
parser.add_argument('--batch-size', type=int, default=1, help='batch size')
parser.add_argument('--dynamic', action='store_true', help='dynamic batch size')
opt = parser.parse_args()
opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand
print_args(vars(opt))
return opt
def main(opt):
run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 25,502 | Python | .py | 482 | 41.925311 | 120 | 0.559732 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,506 | user_manage_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/user_manage_bp.py | from flask import Blueprint, request
from werkzeug.security import generate_password_hash
from database_models import *
from flask_jwt_extended import jwt_required
from extensions import db
from utils.backend_utils.response_utils import response
from utils.backend_utils.colorprinter import *
'''
前后端code约定：
code: 0 成功 前端无消息弹窗
code: 1 失败 前端无消息弹窗
code: 200 前端消息弹窗Success
code: 201 前端消息弹窗Error
code: 202 前端消息弹窗Warning
code: 203 前端消息弹窗Info
code: 204 前端通知弹窗Success
code: 205 前端通知弹窗Error
code: 206 前端通知弹窗Warning
code: 207 前端通知弹窗Info
'''
bp = Blueprint('user-manage', __name__, url_prefix='/user-manage')
@bp.route('/list', methods=['GET'])
@jwt_required(refresh=True)
def get_users():
page = int(request.args.get('currentPage', 1)) # 获取页码，默认为第一页
per_page = int(request.args.get('size', 10)) # 获取每页显示的数据量，默认为 10 条
username = request.args.get('username', '').strip() # 获取用户名，strip() 函数用于去除字符串两端的空白字符
email = request.args.get('email', '').strip() # 获取电子邮箱
# 构造查询语句
query = UserModel.query # 使用 UserModel 模型进行查询
if username: # 如果用户名不为空
query = query.filter(UserModel.username.ilike(f'%{username}%')) # 使用 ilike() 方法查询所有包含 username 的用户名
if email: # 如果电子邮箱不为空
query = query.filter(UserModel.email.ilike(f'%{email}%')) # 使用 ilike() 方法查询所有包含 email 的电子邮箱
# 分页查询
pagination = query.paginate(page=page, per_page=per_page, error_out=False) # 使用 paginate() 方法进行分页查询，不抛出异常
users = pagination.items # 获取当前页的数据
total = pagination.total # 获取总数据量
# 构造返回数据
data = {
'list': [user.to_dict() for user in users], # 将当前页的所有用户数据转换为字典形式，并存储在列表中
'total': total, # 总数据量
}
return response(code=0, data=data, message='获取用户列表成功')
@bp.route('/add', methods=['POST'])
@jwt_required(refresh=True)
def add_user():
username = request.json.get('username', '').strip()
password = request.json.get('password', '').strip()
email = request.json.get('email', '').strip()
roles = request.json.get('roles', '').strip()
if not username or not email or not password:
return response(code=1, message='添加失败，缺少必要参数')
user = UserModel.query.filter_by(email=email).first()
if user is not None:
return response(code=1, message='添加失败，用户邮箱已存在')
roles = RoleModel.query.filter_by(role_name=roles).first()
user = UserModel(username=username,
email=email,
password=generate_password_hash(password),
roles=roles)
db.session.add(user)
db.session.commit()
return response(code=0, message='添加用户成功')
@bp.route('/delete/<int:user_id>', methods=['DELETE'])
@jwt_required(refresh=True)
def delete_user(user_id):
user = UserModel.query.get(user_id)
if user is None:
return response(code=1, message='删除失败，用户不存在')
db.session.delete(user)
db.session.commit()
return response(code=0, message='删除用户成功')
@bp.route('/update', methods=['PUT'])
@jwt_required(refresh=True)
def update_user():
user_id = request.json.get('id', '')
username = request.json.get('username', '').strip()
email = request.json.get('email', '').strip()
status = request.json.get('status', '')
roles = request.json.get('roles', '').strip()
if not username or not email:
return response(code=1, message='修改失败，缺少必要参数')
user = UserModel.query.get(user_id)
role_id = RoleModel.query.filter_by(role_name=roles).first().id
user.username = username
user.email = email
user.status = status
user.role_id = role_id
db.session.commit()
return response(code=0, message='修改用户成功')
| 4,254 | Python | .py | 91 | 34.989011 | 110 | 0.683624 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,507 | auth_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/auth_bp.py | import random
import string
from pprint import pprint
from flask import Blueprint, render_template, jsonify, redirect, url_for, request, session
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity, create_refresh_token
from extensions import db, mail
from flask_mail import Message
from utils.backend_utils.colorprinter import *
from database_models import CaptchaModel, UserModel
from werkzeug.security import generate_password_hash, check_password_hash
from blueprints.froms.login_form import LoginForm
from blueprints.froms.register_form import RegisterForm
from utils.backend_utils.response_utils import response
'''
��端code约定：
code: 0 æˆ�功 å‰�ç«¯æ— æ¶ˆæ�¯å¼¹çª—
code: 1 失败 å‰�ç«¯æ— æ¶ˆæ�¯å¼¹çª—
code: 200 �端消�弹窗Success
code: 201 �端消�弹窗Error
code: 202 �端消�弹窗Warning
code: 203 �端消�弹窗Info
code: 204 �端通知弹窗Success
code: 205 �端通知弹窗Error
code: 206 �端通知弹窗Warning
code: 207 �端通知弹窗Info
'''
# /auth
bp = Blueprint('auth', __name__, url_prefix='/auth')
# è�·å�–登陆验è¯�ç �
@bp.route('/login/captcha', methods=['GET'])
def get_login_captcha():
# 生æˆ�验è¯�ç �
captcha = ''.join(random.sample(string.ascii_letters + string.digits, 5))
# 将验è¯�ç �ä¿�å˜åœ¨sessionä¸
# 默认情况下 Flaskå°†sessionæ•°æ�®å˜å‚¨åœ¨æœ�务器端的内å˜
print_cyan(f'登录验è¯�ç �:{captcha}')
session['captcha'] = captcha
code_url = f'https://dummyimage.com/100x40/dcdfe6/000000.png&text={captcha}'
return response(code=0, data=code_url, message='è�·å�–验è¯�ç �æˆ�功')
@bp.route('/register/captcha', methods=['GET', 'POST'])
def get_register_captcha():
# /captcha/email/<email> 方法ä¸éœ€è¦�æ�¥å�—å�‚æ•° def get_register_captcha(email)
# /captcha/[email protected]
if request.method == 'POST':
email = request.form.get('email')
elif request.method == 'GET':
email = request.args.get('email')
else:
email = None
# 验�当�邮箱是�被注册 在注册时�端表�将会�次验�
user = UserModel.query.filter_by(email=email).first()
if user is None:
if email != '' and email is not None:
# 4/6ä½� éš�机数å—ã€�å—æ¯�ã€�æ•°å—å—æ¯�组å�ˆ
# string.digits*4:0123456789012345678901234567890123456789
# source = string.digits*4
# captcha = random.sample(source, 4)
# captcha = ''.join(captcha)
# captcha = random.randint(10000, 99999)
captcha = ''.join(random.sample(string.ascii_letters + string.digits, 5))
# I/O�作 耗费时间长 �际开�使用队列任务
message = Message(subject='基äº�深度å¦ä¹ 算法的å�ƒåœ¾æ£€æµ‹ç³»ç»ŸéªŒè¯�ç �',
recipients=[email],
body=f'您的验è¯�ç �：{captcha}')
# 📮��邮件📮
mail.send(message)
# memcached/rediså˜å‚¨éªŒè¯�ç �较为å�ˆé€‚ 这里使用数æ�®åº“å˜å‚¨éªŒè¯�ç �
email_captcha = CaptchaModel(email=email, captcha=captcha)
db.session.add(email_captcha)
db.session.commit()
# RESTful API
# {"code": 200/400/500, "message": "", "data": {}}
return response(code=200, message='验è¯�ç �å·²å�‘é€�')
else:
return response(code=201, message='邮箱�能为空')
else:
return response(code=202, message='该邮箱已�被注册')
@bp.route('/user/login', methods=['POST'])
def login():
json_data = request.get_json()
# ��表�数�
form = LoginForm(request.form, data=json_data)
captcha = session.get('captcha')
# å��ç«¯æ ¡éªŒé€šè¿‡
if form.validate():
username = form.username.data
password = form.password.data
user_captcha = form.code.data
# 验è¯�ç �æ ¡éªŒ
if captcha and user_captcha == captcha:
user = UserModel.query.filter_by(username=username).first()
# 用户是å�¦å˜åœ¨
if not user:
return response(code=201, message='用户ä¸�å˜åœ¨è¯·å…ˆæ³¨å†Œ')
# 用户是�被�用
if not user.status:
return response(code=201, message='用户已被�用，请�系管�员')
# 用户å��密ç �æ ¡éªŒ
if check_password_hash(user.password, password):
session['user_id'] = user.id
# 在Flask-JWT-Extendedä¸ï¼Œcreate_access_token()函数用äº�创建一个包å�«ç”¨æˆ·èº«ä»½ä¿¡æ�¯çš„JWT访问令牌。
# 访问令牌通常用äº�验è¯�客户端的身份，并å…�许客户端访问å�—ä¿�护的资æº�。访问令牌通常具有较çŸçš„过期时间，需è¦�ç»�常更新或刷新。
# 创建访问令牌：create_access_token()
# 创建刷新令牌：create_refresh_token()
refresh_token = create_refresh_token(identity=user.id)
data = {'token': refresh_token}
print_cyan('登陆�功')
return response(code=200, data=data, message='登陆�功')
else:
print_cyan('用户å��或密ç �错误')
return response(code=201, message='用户å��或密ç �错误')
else:
print_cyan('验è¯�ç �错误')
return response(code=201, message='验è¯�ç �错误')
else:
# å��ç«¯æ ¡éªŒå¤±è´¥
msg = list(form.errors.values())[0][0]
print_cyan(f'å��ç«¯æ ¡éªŒå¤±è´¥ {msg}')
return response(code=201, message=f'å��ç«¯æ ¡éªŒå¤±è´¥ {msg}')
# GET：��务器��数�
# POST：将客户端的数��交给�务器
@bp.route('/user/register', methods=['POST'])
def register():
json_data = request.get_json()
form = RegisterForm(request.form, data=json_data)
if form.validate():
username = form.username.data
email = form.email.data
password = form.password.data
user = UserModel(username=username,
password=generate_password_hash(password),
email=email)
session['user_id'] = user.id
# 注册�生�Token并返� �端��注册�自动登录
refresh_token = create_refresh_token(identity=user.id)
data = {'token': refresh_token}
db.session.add(user)
db.session.commit()
print_cyan('注册�功')
return response(code=200, data=data, message="注册�功")
else:
msg = list(form.errors.values())[0][0]
print_cyan(f'å��ç«¯æ ¡éªŒå¤±è´¥ {msg}')
return response(code=201, message=f'å��ç«¯æ ¡éªŒå¤±è´¥ {msg}')
@bp.route('/user/info', methods=['GET'])
@jwt_required(refresh=True)
def get_user_info():
user_id = get_jwt_identity()
user = UserModel.query.filter_by(id=user_id, status=True).first()
if user:
data = {
'username': user.username,
'email': user.email,
'roles': [user.roles.role_name],
'join_time': user.join_time.strftime('%Y-%m-%d %H:%M:%S')
}
return response(code=0, data=data, message='��用户信��功')
else:
return response(code=201, message='��用户信�失败')
@bp.route('/switch/role', methods=['POST'])
@jwt_required(refresh=True)
def switch_role():
role = request.json.get('role', '').strip()
if role == 'admin':
admin = UserModel.query.filter_by(username='admin', status=True).first()
refresh_token = create_refresh_token(identity=admin.id)
data = {
'username': admin.username,
'roles': [admin.roles.role_name],
'token': refresh_token
}
return response(code=0, data=data, message='�功切�Admin��')
elif role == 'user':
user = UserModel.query.filter_by(username='user', status=True).first()
refresh_token = create_refresh_token(identity=user.id)
data = {
'username': user.username,
'roles': [user.roles.role_name],
'token': refresh_token
}
return response(code=0, data=data, message='�功切�User��')
else:
return response(code=201, message='切���失败')
# http://localhost:5003/auth/mail/test
@bp.route('/mail/test')
def mail_test():
message = Message(subject='Flask��邮件测试',
recipients=['[email protected]'],
body='Flask��邮件测试')
# Windows下Flask报错�示
# UnicodeEncodeError: 'ascii' codec can't encode characters in position 52-55: ordinal not in range(128)
# 解决方案：https://www.cnblogs.com/Flat-White/p/17261697.html
mail.send(message)
return '邮件���功'
| 8,850 | Python | .py | 194 | 37.489691 | 192 | 0.580739 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,508 | table_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/table_bp.py | from flask import Blueprint, request
from werkzeug.security import generate_password_hash
from database_models import *
from flask_jwt_extended import jwt_required
from extensions import db
from utils.backend_utils.response_utils import response
from utils.backend_utils.colorprinter import *
'''
前后端code约定：
code: 0 成功 前端无消息弹窗
code: 1 失败 前端无消息弹窗
code: 200 前端消息弹窗Success
code: 201 前端消息弹窗Error
code: 202 前端消息弹窗Warning
code: 203 前端消息弹窗Info
code: 204 前端通知弹窗Success
code: 205 前端通知弹窗Error
code: 206 前端通知弹窗Warning
code: 207 前端通知弹窗Info
'''
bp = Blueprint('table', __name__, url_prefix='/table')
@bp.route('/list', methods=['GET'])
@jwt_required(refresh=True)
def get_users():
page = int(request.args.get('currentPage', 1))
per_page = int(request.args.get('size', 10))
username = request.args.get('username', '').strip()
email = request.args.get('email', '').strip()
query = UserModel.query
if username:
query = query.filter(UserModel.username.ilike(f'%{username}%'))
if email:
query = query.filter(UserModel.email.ilike(f'%{email}%'))
pagination = query.paginate(page=page, per_page=per_page, error_out=False)
users = pagination.items
total = pagination.total
data = {
'list': [user.to_dict() for user in users],
'total': total,
}
return response(code=0, data=data, message='获取用户列表成功')
@bp.route('/add', methods=['POST'])
@jwt_required(refresh=True)
def add_user():
username = request.json.get('username', '').strip()
password = request.json.get('password', '').strip()
email = request.json.get('email', '').strip()
roles = request.json.get('roles', '').strip()
if not username or not email or not password:
return response(code=1, message='添加失败，缺少必要参数')
user = UserModel.query.filter_by(email=email).first()
if user is not None:
return response(code=1, message='添加失败，用户邮箱已存在')
roles = RoleModel.query.filter_by(role_name=roles).first()
user = UserModel(username=username,
email=email,
password=generate_password_hash(password),
roles=roles)
db.session.add(user)
db.session.commit()
return response(code=0, message='添加用户成功')
@bp.route('/delete/<int:user_id>', methods=['DELETE'])
@jwt_required(refresh=True)
def delete_user(user_id):
user = UserModel.query.get(user_id)
if user is None:
return response(code=1, message='删除失败，用户不存在')
db.session.delete(user)
db.session.commit()
return response(code=0, message='删除用户成功')
@bp.route('/update', methods=['PUT'])
@jwt_required(refresh=True)
def update_user():
user_id = request.json.get('id', '')
username = request.json.get('username', '').strip()
email = request.json.get('email', '').strip()
status = request.json.get('status', '')
roles = request.json.get('roles', '').strip()
if not username or not email:
return response(code=1, message='修改失败，缺少必要参数')
user = UserModel.query.get(user_id)
role_id = RoleModel.query.filter_by(role_name=roles).first().id
user.username = username
user.email = email
user.status = status
user.role_id = role_id
db.session.commit()
return response(code=0, message='修改用户成功')
| 3,543 | Python | .py | 88 | 32.454545 | 78 | 0.682494 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,509 | detect_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/detect_bp.py | import os
from pprint import pprint
from flask import Blueprint, request, render_template, g, redirect, session
from PIL import Image
import datetime
import base64
from io import BytesIO
from flask_jwt_extended import jwt_required
from database_models import WeightsModel
from utils.backend_utils.dir_utils import *
from utils.backend_utils.model_handler import load_model
from utils.backend_utils.response_utils import response
from utils.backend_utils.colorprinter import *
'''
前后端code约定：
code: 0 成功 前端无消息弹窗
code: 1 失败 前端无消息弹窗
code: 200 前端消息弹窗Success
code: 201 前端消息弹窗Error
code: 202 前端消息弹窗Warning
code: 203 前端消息弹窗Info
code: 204 前端通知弹窗Success
code: 205 前端通知弹窗Error
code: 206 前端通知弹窗Warning
code: 207 前端通知弹窗Info
'''
bp = Blueprint(name='detect', import_name=__name__)
DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S-%f"
@bp.route('/weights/current')
@jwt_required(refresh=True)
def get_current_weights():
weights_path = session['weights_path']
current_weights = WeightsModel.query.filter_by(weights_relative_path=weights_path).first()
weights_name = current_weights.weights_name
weights_version = current_weights.weights_version
data = {
'weightsName': weights_name,
'weightsVersion': weights_version,
}
return response(code=0, message='获取当前调用权重成功', data=data)
@bp.route('/weights/list')
@jwt_required(refresh=True)
def get_all_enable_weights():
all_enable_weights = []
weights_models = WeightsModel.query.filter_by(enable=True).all()
for weights_model in weights_models:
all_enable_weights.append({
'weightsName': weights_model.weights_name,
'weightsVersion': weights_model.weights_version
})
data = {'list': all_enable_weights}
return response(code=0, message='获取所有可调用权重成功', data=data)
@bp.route('/weights/switch', methods=['POST'])
@jwt_required(refresh=True)
def switch_weights():
weights_name = request.json.get('switchWeightsName', '').strip()
weights_version = request.json.get('switchWeightsVersion', '').strip()
repo_dir = session['repo_dir']
new_weights = WeightsModel.query.filter_by(weights_name=weights_name,
weights_version=weights_version).first()
if new_weights and new_weights.enable:
new_weights_path = new_weights.weights_relative_path
new_weights_name = new_weights.weights_name
new_weights_version = new_weights.weights_version
model_load_path = os.path.join(repo_dir, new_weights_path)
print_cyan(f'切换成功，当前调用权重：{new_weights_name}，权重版本{weights_version}')
session['repo_dir'] = repo_dir
session['weights_path'] = new_weights_path
session['model_load_path'] = model_load_path
session['weights_name'] = new_weights_name
data = {
'weightsName': new_weights_name,
'weightsVersion': new_weights_version,
}
return response(code=200, message='切换模型成功', data=data)
elif not new_weights:
return response(code=201, message='切换模型失败，当前模型不存在')
else:
return response(code=201, message='切换模型失败，当前模型暂不可用')
@bp.route('/upload', methods=['POST'])
def upload_file():
if "file" not in request.files:
return response(code=1, message='模型推断失败，未检测到文件')
file = request.files["file"]
if not file:
return response(code=1, message='模型推断失败，未检测到文件')
# 加载模型
if session['weights_name'] == session['default_weights_name']:
model = g.model
else:
model = load_model(repo_dir=session['repo_dir'],
model_load_path=session['model_load_path'])
# 获取上传的文件
file = request.files['file']
# inference
original_base64, result_base64, detect_result = inference_image(model, file)
data = {
'originalBase64': original_base64,
'resultBase64': result_base64,
'detectResult': detect_result,
}
return response(code=0, message='模型推断已完成', data=data)
# 模型推断-图片
def inference_image(model, file):
img_bytes = file.read()
img = Image.open(BytesIO(img_bytes))
# inference
results = model([img])
# 处理返回检测结果
result_df = results.pandas().xyxy[0]
# 保留confidence列的两位小数
result_df['confidence'] = result_df['confidence'].round(2)
# 重命名name列为className列
result_df = result_df.rename(columns={'name': 'className'})
# 提取confidence和className列，转换为字典
detect_result = result_df[['confidence', 'className']].to_dict('records')
# 处理返回结果图片 base64编码
results.render() # updates results.ims with boxes and labels
now_time = datetime.datetime.now().strftime(DATETIME_FORMAT)
img_save_name = f"static/detect_result/{now_time}.png"
output_dir = os.path.join(g.repo_dir, 'static/detect_result')
create_dir(output_dir)
Image.fromarray(results.imgs[0]).save(img_save_name)
# base64 encoded image with results
original_base64 = base64.b64encode(img_bytes).decode('utf-8')
result_base64 = batch_base64_encode_image(results)
return original_base64, result_base64, detect_result
# base64编码推断后图片
def batch_base64_encode_image(results_images):
for im in results_images.imgs:
buffered = BytesIO()
im_base64 = Image.fromarray(im)
im_base64.save(buffered, format="JPEG")
return base64.b64encode(buffered.getvalue()).decode('utf-8')
| 5,824 | Python | .py | 134 | 34.402985 | 94 | 0.696952 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,510 | detect_demo_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/detect_demo_bp.py | from flask import Blueprint, request, render_template, g, redirect, session
from PIL import Image
import datetime
import base64
from io import BytesIO
from utils.backend_utils.dir_utils import *
from utils.backend_utils.model_handler import load_model
bp = Blueprint(name='detect_demo', import_name=__name__)
DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S-%f"
# 模型推断demo
@bp.route("/upload", methods=["GET", "POST"])
def detect():
if session['weights_name'] == session['default_weights_name']:
model = g.model
else:
model = load_model(repo_dir=session['repo_dir'],
model_load_path=session['model_load_path'])
if request.method == "POST":
if "file" not in request.files:
return redirect(request.url)
file = request.files["file"]
if not file:
return
img_bytes = file.read()
img = Image.open(BytesIO(img_bytes))
results = model([img])
results.render() # updates results.imgs with boxes and labels
now_time = datetime.datetime.now().strftime(DATETIME_FORMAT)
img_save_name = f"static/detect_result/{now_time}.png"
output_dir = os.path.join(g.repo_dir, 'static/detect_result')
create_dir(output_dir)
Image.fromarray(results.imgs[0]).save(img_save_name)
return redirect('/' + img_save_name)
return render_template("index.html") | 1,418 | Python | .py | 34 | 34.676471 | 75 | 0.653734 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,511 | server_bp.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/server_bp.py | from flask import Blueprint, session
from utils.backend_utils.response_utils import response
from utils.backend_utils.colorprinter import *
bp = Blueprint('server', __name__, url_prefix='/server')
# 查看服务端Session
@bp.route('/session/list', methods=['GET'])
def session_data():
print_cyan(session)
return response(code=200, data=session, message='获取session成功')
# 清除服务端Session
@bp.route('/session/clear')
def logout():
session.clear()
return response(code=200, message='清除session成功')
| 539 | Python | .py | 14 | 33.357143 | 66 | 0.755694 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,512 | login_form.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/froms/login_form.py | import wtforms
from wtforms.validators import Email, Length, EqualTo, InputRequired, DataRequired
from database_models import UserModel, CaptchaModel
from extensions import db
from flask import request
class LoginForm(wtforms.Form):
username = wtforms.StringField(validators=[DataRequired(message='用户名不能为空')])
password = wtforms.StringField(validators=[DataRequired(message='密码不能为空'),
Length(min=4, max=20, message='密码字符数限制：4-20')])
code = wtforms.StringField(validators=[DataRequired(message='验证码不能为空')])
| 623 | Python | .py | 10 | 49.6 | 94 | 0.738739 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,513 | register_form.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/blueprints/froms/register_form.py | import wtforms
from wtforms.validators import Email, Length, EqualTo, InputRequired, DataRequired
from database_models import UserModel, CaptchaModel
from extensions import db
class RegisterForm(wtforms.Form):
username = wtforms.StringField(validators=[DataRequired(message='用户名不能为空'),
Length(min=2, max=20, message='用户名字符数限制：2-20')])
email = wtforms.StringField(validators=[Email(message='邮箱格式错误')])
captcha = wtforms.StringField(validators=[DataRequired(message='验证码不能为空')])
password = wtforms.StringField(validators=[DataRequired(message='密码不能为空'),
Length(min=4, max=20, message='密码字符数限制：4-20')])
confirm_password = wtforms.StringField(validators=[EqualTo('password', message='两次输入密码不一致')])
# 验证邮箱是否已经被注册
def validate_email(self, filed):
email = filed.data
user = UserModel.query.filter_by(email=email).first()
if user:
raise wtforms.ValidationError(message='该邮箱已经被注册')
# 验证验证码是否正确
def validate_captcha(self, filed):
captcha = filed.data
email = self.email.data
captcha_model = CaptchaModel.query.filter_by(email=email, captcha=captcha).first()
if not captcha_model:
raise wtforms.ValidationError('邮箱或验证码错误')
else:
# 可以删掉已验证的captcha_model
# 但是每次使用完就删可能会降低服务器性能
# db.session.delete(captcha_model)
# 逻辑删除 设置已使用字段为True
captcha_model.is_used = True
db.session.commit()
"""
Validate the form by calling ``validate`` on each field.
Returns ``True`` if validation passes.
If the form defines a ``validate_<fieldname>`` method, it is
appended as an extra validator for the field's ``validate``.
:param extra_validators: A dict mapping field names to lists of
extra validator methods to run. Extra validators run after
validators passed when creating the field. If the form has
``validate_<fieldname>``, it is the last extra validator.
"""
| 2,337 | Python | .py | 42 | 40.285714 | 97 | 0.665683 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,514 | script.py.mako | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/migrations/script.py.mako | """${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
| 494 | Python | .py | 17 | 27.176471 | 43 | 0.725532 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,515 | env.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/migrations/env.py | import logging
from logging.config import fileConfig
from flask import current_app
from alembic import context
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
logger = logging.getLogger('alembic.env')
def get_engine():
try:
# this works with Flask-SQLAlchemy<3 and Alchemical
return current_app.extensions['migrate'].db.get_engine()
except TypeError:
# this works with Flask-SQLAlchemy>=3
return current_app.extensions['migrate'].db.engine
def get_engine_url():
try:
return get_engine().url.render_as_string(hide_password=False).replace(
'%', '%%')
except AttributeError:
return str(get_engine().url).replace('%', '%%')
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
config.set_main_option('sqlalchemy.url', get_engine_url())
target_db = current_app.extensions['migrate'].db
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def get_metadata():
if hasattr(target_db, 'metadatas'):
return target_db.metadatas[None]
return target_db.metadata
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url, target_metadata=get_metadata(), literal_binds=True
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
# this callback is used to prevent an auto-migration from being generated
# when there are no changes to the schema
# reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
def process_revision_directives(context, revision, directives):
if getattr(config.cmd_opts, 'autogenerate', False):
script = directives[0]
if script.upgrade_ops.is_empty():
directives[:] = []
logger.info('No changes in schema detected.')
connectable = get_engine()
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=get_metadata(),
process_revision_directives=process_revision_directives,
**current_app.extensions['migrate'].configure_args
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
| 3,228 | Python | .py | 81 | 34.148148 | 78 | 0.702053 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,516 | 6475298b24f3_.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/migrations/versions/6475298b24f3_.py | """empty message
Revision ID: 6475298b24f3
Revises:
Create Date: 2023-05-20 21:22:21.144304
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '6475298b24f3'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('captcha',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
sa.Column('email', sa.String(length=100), nullable=True, comment='验证邮箱'),
sa.Column('captcha', sa.String(length=100), nullable=False, comment='验证码'),
sa.Column('create_time', sa.DateTime(), nullable=True, comment='创建时间'),
sa.Column('is_used', sa.Boolean(), nullable=True, comment='是否使用'),
sa.PrimaryKeyConstraint('id')
)
op.create_table('dataset',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='数据集id'),
sa.Column('dataset_name', sa.String(length=100), nullable=False, comment='数据集名称'),
sa.Column('class_num', sa.Integer(), nullable=False, comment='类别数量'),
sa.Column('total_num', sa.Integer(), nullable=False, comment='总数量'),
sa.Column('train_num', sa.Integer(), nullable=False, comment='训练集数量'),
sa.Column('val_num', sa.Integer(), nullable=False, comment='验证集数量'),
sa.Column('test_exist', sa.Boolean(), nullable=False, comment='是否存在测试集'),
sa.Column('test_num', sa.Integer(), nullable=True, comment='测试集数量'),
sa.PrimaryKeyConstraint('id')
)
op.create_table('role',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='角色id'),
sa.Column('role_name', sa.String(length=100), nullable=False, comment='角色名称'),
sa.Column('role_desc', sa.String(length=100), nullable=False, comment='角色描述'),
sa.PrimaryKeyConstraint('id')
)
op.create_table('image',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='图片id'),
sa.Column('image_name', sa.String(length=100), nullable=False, comment='图片名称'),
sa.Column('image_absolute_path', sa.Text(), nullable=True, comment='图片绝对路径'),
sa.Column('image_relative_path', sa.Text(), nullable=True, comment='图片相对路径'),
sa.Column('image_type', sa.String(length=100), nullable=False, comment='图片类型'),
sa.Column('dataset_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['dataset_id'], ['dataset.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('label',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='标注id'),
sa.Column('label_name', sa.String(length=100), nullable=False, comment='标注名称'),
sa.Column('dataset_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['dataset_id'], ['dataset.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('user',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='用户id'),
sa.Column('username', sa.String(length=100), nullable=False, comment='用户名'),
sa.Column('password', sa.String(length=500), nullable=False, comment='密码'),
sa.Column('email', sa.String(length=100), nullable=False, comment='邮箱'),
sa.Column('join_time', sa.DateTime(), nullable=True, comment='加入时间'),
sa.Column('status', sa.Boolean(), nullable=True, comment='是否启用'),
sa.Column('role_id', sa.Integer(), nullable=True, comment='用户角色'),
sa.ForeignKeyConstraint(['role_id'], ['role.id'], ),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('email')
)
op.create_table('weights',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='权重id'),
sa.Column('weights_name', sa.String(length=100), nullable=False, comment='权重名称'),
sa.Column('weights_relative_path', sa.Text(), nullable=False, comment='权重相对路径'),
sa.Column('weights_absolute_path', sa.Text(), nullable=True, comment='权重绝对路径'),
sa.Column('weights_version', sa.String(length=100), nullable=False, comment='权重版本'),
sa.Column('enable', sa.Boolean(), nullable=False, comment='是否启用'),
sa.Column('dataset_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['dataset_id'], ['dataset.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('detect_result',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='检测结果id'),
sa.Column('detect_result', sa.Text(), nullable=False, comment='检测结果'),
sa.Column('detect_result_image_name', sa.String(length=100), nullable=False, comment='检测结果图片名称'),
sa.Column('detect_time', sa.DateTime(), nullable=True, comment='检测时间'),
sa.Column('user_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('image_label_info',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False, comment='图片标注信息id'),
sa.Column('image_id', sa.Integer(), nullable=True, comment='图片id'),
sa.Column('label_id', sa.Integer(), nullable=True, comment='标注id'),
sa.ForeignKeyConstraint(['image_id'], ['image.id'], ),
sa.ForeignKeyConstraint(['label_id'], ['label.id'], ),
sa.PrimaryKeyConstraint('id')
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_table('image_label_info')
op.drop_table('detect_result')
op.drop_table('weights')
op.drop_table('user')
op.drop_table('label')
op.drop_table('image')
op.drop_table('role')
op.drop_table('dataset')
op.drop_table('captcha')
# ### end Alembic commands ###
| 5,900 | Python | .py | 109 | 46.495413 | 101 | 0.679207 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,517 | general.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/general.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
General utils
"""
import contextlib
import glob
import inspect
import logging
import math
import os
import platform
import random
import re
import shutil
import signal
import sys
import threading
import time
import urllib
from datetime import datetime
from itertools import repeat
from multiprocessing.pool import ThreadPool
from pathlib import Path
from subprocess import check_output
from typing import Optional
from zipfile import ZipFile
import cv2
import numpy as np
import pandas as pd
import pkg_resources as pkg
import torch
import torchvision
import yaml
from utils.downloads import gsutil_getsize
from utils.metrics import box_iou, fitness
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
RANK = int(os.getenv('RANK', -1))
# Settings
DATASETS_DIR = ROOT.parent / 'datasets' # YOLOv5 datasets directory
NUM_THREADS = min(8, max(1, os.cpu_count() - 1)) # number of YOLOv5 multiprocessing threads
AUTOINSTALL = str(os.getenv('YOLOv5_AUTOINSTALL', True)).lower() == 'true' # global auto-install mode
VERBOSE = str(os.getenv('YOLOv5_VERBOSE', True)).lower() == 'true' # global verbose mode
FONT = 'Arial.ttf' # https://ultralytics.com/assets/Arial.ttf
torch.set_printoptions(linewidth=320, precision=5, profile='long')
np.set_printoptions(linewidth=320, formatter={'float_kind': '{:11.5g}'.format}) # format short g, %precision=5
pd.options.display.max_columns = 10
cv2.setNumThreads(0) # prevent OpenCV from multithreading (incompatible with PyTorch DataLoader)
os.environ['NUMEXPR_MAX_THREADS'] = str(NUM_THREADS) # NumExpr max threads
os.environ['OMP_NUM_THREADS'] = '1' if platform.system() == 'darwin' else str(NUM_THREADS) # OpenMP (PyTorch and SciPy)
def is_ascii(s=''):
# Is string composed of all ASCII (no UTF) characters? (note str().isascii() introduced in python 3.7)
s = str(s) # convert list, tuple, None, etc. to str
return len(s.encode().decode('ascii', 'ignore')) == len(s)
def is_chinese(s='人工智能'):
# Is string composed of any Chinese characters?
return bool(re.search('[\u4e00-\u9fff]', str(s)))
def is_colab():
# Is environment a Google Colab instance?
return 'COLAB_GPU' in os.environ
def is_kaggle():
# Is environment a Kaggle Notebook?
return os.environ.get('PWD') == '/kaggle/working' and os.environ.get('KAGGLE_URL_BASE') == 'https://www.kaggle.com'
def is_docker() -> bool:
"""Check if the process runs inside a docker container."""
if Path("/.dockerenv").exists():
return True
try: # check if docker is in control groups
with open("/proc/self/cgroup") as file:
return any("docker" in line for line in file)
except OSError:
return False
def is_writeable(dir, test=False):
# Return True if directory has write permissions, test opening a file with write permissions if test=True
if not test:
return os.access(dir, os.W_OK) # possible issues on Windows
file = Path(dir) / 'tmp.txt'
try:
with open(file, 'w'): # open file with write permissions
pass
file.unlink() # remove file
return True
except OSError:
return False
def set_logging(name=None, verbose=VERBOSE):
# Sets level and returns logger
if is_kaggle() or is_colab():
for h in logging.root.handlers:
logging.root.removeHandler(h) # remove all handlers associated with the root logger object
rank = int(os.getenv('RANK', -1)) # rank in world for Multi-GPU trainings
level = logging.INFO if verbose and rank in {-1, 0} else logging.ERROR
log = logging.getLogger(name)
log.setLevel(level)
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(message)s"))
handler.setLevel(level)
log.addHandler(handler)
set_logging() # run before defining LOGGER
LOGGER = logging.getLogger("yolov5") # define globally (used in train.py, val.py, detect.py, etc.)
if platform.system() == 'Windows':
for fn in LOGGER.info, LOGGER.warning:
setattr(LOGGER, fn.__name__, lambda x: fn(emojis(x))) # emoji safe logging
def user_config_dir(dir='Ultralytics', env_var='YOLOV5_CONFIG_DIR'):
# Return path of user configuration directory. Prefer environment variable if exists. Make dir if required.
env = os.getenv(env_var)
if env:
path = Path(env) # use environment variable
else:
cfg = {'Windows': 'AppData/Roaming', 'Linux': '.config', 'Darwin': 'Library/Application Support'} # 3 OS dirs
path = Path.home() / cfg.get(platform.system(), '') # OS-specific config dir
path = (path if is_writeable(path) else Path('/tmp')) / dir # GCP and AWS lambda fix, only /tmp is writeable
path.mkdir(exist_ok=True) # make if required
return path
CONFIG_DIR = user_config_dir() # Ultralytics settings dir
class Profile(contextlib.ContextDecorator):
# Usage: @Profile() decorator or 'with Profile():' context manager
def __enter__(self):
self.start = time.time()
def __exit__(self, type, value, traceback):
print(f'Profile results: {time.time() - self.start:.5f}s')
class Timeout(contextlib.ContextDecorator):
# Usage: @Timeout(seconds) decorator or 'with Timeout(seconds):' context manager
def __init__(self, seconds, *, timeout_msg='', suppress_timeout_errors=True):
self.seconds = int(seconds)
self.timeout_message = timeout_msg
self.suppress = bool(suppress_timeout_errors)
def _timeout_handler(self, signum, frame):
raise TimeoutError(self.timeout_message)
def __enter__(self):
if platform.system() != 'Windows': # not supported on Windows
signal.signal(signal.SIGALRM, self._timeout_handler) # Set handler for SIGALRM
signal.alarm(self.seconds) # start countdown for SIGALRM to be raised
def __exit__(self, exc_type, exc_val, exc_tb):
if platform.system() != 'Windows':
signal.alarm(0) # Cancel SIGALRM if it's scheduled
if self.suppress and exc_type is TimeoutError: # Suppress TimeoutError
return True
class WorkingDirectory(contextlib.ContextDecorator):
# Usage: @WorkingDirectory(dir) decorator or 'with WorkingDirectory(dir):' context manager
def __init__(self, new_dir):
self.dir = new_dir # new dir
self.cwd = Path.cwd().resolve() # current dir
def __enter__(self):
os.chdir(self.dir)
def __exit__(self, exc_type, exc_val, exc_tb):
os.chdir(self.cwd)
def try_except(func):
# try-except function. Usage: @try_except decorator
def handler(*args, **kwargs):
try:
func(*args, **kwargs)
except Exception as e:
print(e)
return handler
def threaded(func):
# Multi-threads a target function and returns thread. Usage: @threaded decorator
def wrapper(*args, **kwargs):
thread = threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True)
thread.start()
return thread
return wrapper
def methods(instance):
# Get class/instance methods
return [f for f in dir(instance) if callable(getattr(instance, f)) and not f.startswith("__")]
def print_args(args: Optional[dict] = None, show_file=True, show_fcn=False):
# Print function arguments (optional args dict)
x = inspect.currentframe().f_back # previous frame
file, _, fcn, _, _ = inspect.getframeinfo(x)
if args is None: # get args automatically
args, _, _, frm = inspect.getargvalues(x)
args = {k: v for k, v in frm.items() if k in args}
try:
file = Path(file).resolve().relative_to(ROOT).with_suffix('')
except ValueError:
file = Path(file).stem
s = (f'{file}: ' if show_file else '') + (f'{fcn}: ' if show_fcn else '')
LOGGER.info(colorstr(s) + ', '.join(f'{k}={v}' for k, v in args.items()))
def init_seeds(seed=0, deterministic=False):
# Initialize random number generator (RNG) seeds https://pytorch.org/docs/stable/notes/randomness.html
# cudnn seed 0 settings are slower and more reproducible, else faster and less reproducible
import torch.backends.cudnn as cudnn
if deterministic and check_version(torch.__version__, '1.12.0'): # https://github.com/ultralytics/yolov5/pull/8213
torch.use_deterministic_algorithms(True)
os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
cudnn.benchmark, cudnn.deterministic = (False, True) if seed == 0 else (True, False)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # for Multi-GPU, exception safe
def intersect_dicts(da, db, exclude=()):
# Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values
return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}
def get_latest_run(search_dir='.'):
# Return path to most recent 'last.pt' in /runs (i.e. to --resume from)
last_list = glob.glob(f'{search_dir}/**/last*.pt', recursive=True)
return max(last_list, key=os.path.getctime) if last_list else ''
def emojis(str=''):
# Return platform-dependent emoji-safe version of string
return str.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else str
def file_age(path=__file__):
# Return days since last file update
dt = (datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime)) # delta
return dt.days # + dt.seconds / 86400 # fractional days
def file_date(path=__file__):
# Return human-readable file modification date, i.e. '2021-3-26'
t = datetime.fromtimestamp(Path(path).stat().st_mtime)
return f'{t.year}-{t.month}-{t.day}'
def file_size(path):
# Return file/dir size (MB)
mb = 1 << 20 # bytes to MiB (1024 ** 2)
path = Path(path)
if path.is_file():
return path.stat().st_size / mb
elif path.is_dir():
return sum(f.stat().st_size for f in path.glob('**/*') if f.is_file()) / mb
else:
return 0.0
def check_online():
# Check internet connectivity
import socket
try:
socket.create_connection(("1.1.1.1", 443), 5) # check host accessibility
return True
except OSError:
return False
def git_describe(path=ROOT): # path must be a directory
# Return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
try:
assert (Path(path) / '.git').is_dir()
return check_output(f'git -C {path} describe --tags --long --always', shell=True).decode()[:-1]
except Exception:
return ''
@try_except
@WorkingDirectory(ROOT)
def check_git_status(repo='ultralytics/yolov5'):
# YOLOv5 status check, recommend 'git pull' if code is out of date
url = f'https://github.com/{repo}'
msg = f', for updates see {url}'
s = colorstr('github: ') # string
assert Path('.git').exists(), s + 'skipping check (not a git repository)' + msg
assert check_online(), s + 'skipping check (offline)' + msg
splits = re.split(pattern=r'\s', string=check_output('git remote -v', shell=True).decode())
matches = [repo in s for s in splits]
if any(matches):
remote = splits[matches.index(True) - 1]
else:
remote = 'ultralytics'
check_output(f'git remote add {remote} {url}', shell=True)
check_output(f'git fetch {remote}', shell=True, timeout=5) # git fetch
branch = check_output('git rev-parse --abbrev-ref HEAD', shell=True).decode().strip() # checked out
n = int(check_output(f'git rev-list {branch}..{remote}/master --count', shell=True)) # commits behind
if n > 0:
pull = 'git pull' if remote == 'origin' else f'git pull {remote} master'
s += f"⚠� YOLOv5 is out of date by {n} commit{'s' * (n > 1)}. Use `{pull}` or `git clone {url}` to update."
else:
s += f'up to date with {url} ✅'
LOGGER.info(s)
def check_python(minimum='3.7.0'):
# Check current python version vs. required python version
check_version(platform.python_version(), minimum, name='Python ', hard=True)
def check_version(current='0.0.0', minimum='0.0.0', name='version ', pinned=False, hard=False, verbose=False):
# Check version vs. required version
current, minimum = (pkg.parse_version(x) for x in (current, minimum))
result = (current == minimum) if pinned else (current >= minimum) # bool
s = f'{name}{minimum} required by YOLOv5, but {name}{current} is currently installed' # string
if hard:
assert result, s # assert min requirements met
if verbose and not result:
LOGGER.warning(s)
return result
@try_except
def check_requirements(requirements=ROOT / 'requirements.txt', exclude=(), install=True, cmds=()):
# Check installed dependencies meet YOLOv5 requirements (pass *.txt file or list of packages)
prefix = colorstr('red', 'bold', 'requirements:')
check_python() # check python version
if isinstance(requirements, (str, Path)): # requirements.txt file
file = Path(requirements)
assert file.exists(), f"{prefix} {file.resolve()} not found, check failed."
with file.open() as f:
requirements = [f'{x.name}{x.specifier}' for x in pkg.parse_requirements(f) if x.name not in exclude]
else: # list or tuple of packages
requirements = [x for x in requirements if x not in exclude]
n = 0 # number of packages updates
for i, r in enumerate(requirements):
try:
pkg.require(r)
except Exception: # DistributionNotFound or VersionConflict if requirements not met
s = f"{prefix} {r} not found and is required by YOLOv5"
if install and AUTOINSTALL: # check environment variable
LOGGER.info(f"{s}, attempting auto-update...")
try:
assert check_online(), f"'pip install {r}' skipped (offline)"
LOGGER.info(check_output(f'pip install "{r}" {cmds[i] if cmds else ""}', shell=True).decode())
n += 1
except Exception as e:
LOGGER.warning(f'{prefix} {e}')
else:
LOGGER.info(f'{s}. Please install and rerun your command.')
if n: # if packages updated
source = file.resolve() if 'file' in locals() else requirements
s = f"{prefix} {n} package{'s' * (n > 1)} updated per {source}\n" \
f"{prefix} ⚠� {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\n"
LOGGER.info(s)
def check_img_size(imgsz, s=32, floor=0):
# Verify image size is a multiple of stride s in each dimension
if isinstance(imgsz, int): # integer i.e. img_size=640
new_size = max(make_divisible(imgsz, int(s)), floor)
else: # list i.e. img_size=[640, 480]
imgsz = list(imgsz) # convert to list if tuple
new_size = [max(make_divisible(x, int(s)), floor) for x in imgsz]
if new_size != imgsz:
LOGGER.warning(f'WARNING: --img-size {imgsz} must be multiple of max stride {s}, updating to {new_size}')
return new_size
def check_imshow():
# Check if environment supports image displays
try:
assert not is_docker(), 'cv2.imshow() is disabled in Docker environments'
assert not is_colab(), 'cv2.imshow() is disabled in Google Colab environments'
cv2.imshow('test', np.zeros((1, 1, 3)))
cv2.waitKey(1)
cv2.destroyAllWindows()
cv2.waitKey(1)
return True
except Exception as e:
LOGGER.warning(f'WARNING: Environment does not support cv2.imshow() or PIL Image.show() image displays\n{e}')
return False
def check_suffix(file='yolov5s.pt', suffix=('.pt',), msg=''):
# Check file(s) for acceptable suffix
if file and suffix:
if isinstance(suffix, str):
suffix = [suffix]
for f in file if isinstance(file, (list, tuple)) else [file]:
s = Path(f).suffix.lower() # file suffix
if len(s):
assert s in suffix, f"{msg}{f} acceptable suffix is {suffix}"
def check_yaml(file, suffix=('.yaml', '.yml')):
# Search/download YAML file (if necessary) and return path, checking suffix
return check_file(file, suffix)
def check_file(file, suffix=''):
# Search/download file (if necessary) and return path
check_suffix(file, suffix) # optional
file = str(file) # convert to str()
if Path(file).is_file() or not file: # exists
return file
elif file.startswith(('http:/', 'https:/')): # download
url = file # warning: Pathlib turns :// -> :/
file = Path(urllib.parse.unquote(file).split('?')[0]).name # '%2F' to '/', split https://url.com/file.txt?auth
if Path(file).is_file():
LOGGER.info(f'Found {url} locally at {file}') # file already exists
else:
LOGGER.info(f'Downloading {url} to {file}...')
torch.hub.download_url_to_file(url, file)
assert Path(file).exists() and Path(file).stat().st_size > 0, f'File download failed: {url}' # check
return file
elif file.startswith('clearml://'): # ClearML Dataset ID
assert 'clearml' in sys.modules, "ClearML is not installed, so cannot use ClearML dataset. Try running 'pip install clearml'."
return file
else: # search
files = []
for d in 'data', 'models', 'utils': # search directories
files.extend(glob.glob(str(ROOT / d / '**' / file), recursive=True)) # find file
assert len(files), f'File not found: {file}' # assert file was found
assert len(files) == 1, f"Multiple files match '{file}', specify exact path: {files}" # assert unique
return files[0] # return file
def check_font(font=FONT, progress=False):
# Download font to CONFIG_DIR if necessary
font = Path(font)
file = CONFIG_DIR / font.name
if not font.exists() and not file.exists():
url = "https://ultralytics.com/assets/" + font.name
LOGGER.info(f'Downloading {url} to {file}...')
torch.hub.download_url_to_file(url, str(file), progress=progress)
def check_dataset(data, autodownload=True):
# Download, check and/or unzip dataset if not found locally
# Download (optional)
extract_dir = ''
if isinstance(data, (str, Path)) and str(data).endswith('.zip'): # i.e. gs://bucket/dir/coco128.zip
download(data, dir=f'{DATASETS_DIR}/{Path(data).stem}', unzip=True, delete=False, curl=False, threads=1)
data = next((DATASETS_DIR / Path(data).stem).rglob('*.yaml'))
extract_dir, autodownload = data.parent, False
# Read yaml (optional)
if isinstance(data, (str, Path)):
with open(data, errors='ignore') as f:
data = yaml.safe_load(f) # dictionary
# Checks
for k in 'train', 'val', 'nc':
assert k in data, f"data.yaml '{k}:' field missing �"
if 'names' not in data:
LOGGER.warning("data.yaml 'names:' field missing ⚠�, assigning default names 'class0', 'class1', etc.")
data['names'] = [f'class{i}' for i in range(data['nc'])] # default names
# Resolve paths
path = Path(extract_dir or data.get('path') or '') # optional 'path' default to '.'
if not path.is_absolute():
path = (ROOT / path).resolve()
for k in 'train', 'val', 'test':
if data.get(k): # prepend path
data[k] = str(path / data[k]) if isinstance(data[k], str) else [str(path / x) for x in data[k]]
# Parse yaml
train, val, test, s = (data.get(x) for x in ('train', 'val', 'test', 'download'))
if val:
val = [Path(x).resolve() for x in (val if isinstance(val, list) else [val])] # val path
if not all(x.exists() for x in val):
LOGGER.info('\nDataset not found ⚠�, missing paths %s' % [str(x) for x in val if not x.exists()])
if not s or not autodownload:
raise Exception('Dataset not found �')
t = time.time()
root = path.parent if 'path' in data else '..' # unzip directory i.e. '../'
if s.startswith('http') and s.endswith('.zip'): # URL
f = Path(s).name # filename
LOGGER.info(f'Downloading {s} to {f}...')
torch.hub.download_url_to_file(s, f)
Path(root).mkdir(parents=True, exist_ok=True) # create root
ZipFile(f).extractall(path=root) # unzip
Path(f).unlink() # remove zip
r = None # success
elif s.startswith('bash '): # bash script
LOGGER.info(f'Running {s} ...')
r = os.system(s)
else: # python script
r = exec(s, {'yaml': data}) # return None
dt = f'({round(time.time() - t, 1)}s)'
s = f"success ✅ {dt}, saved to {colorstr('bold', root)}" if r in (0, None) else f"failure {dt} �"
LOGGER.info(f"Dataset download {s}")
check_font('Arial.ttf' if is_ascii(data['names']) else 'Arial.Unicode.ttf', progress=True) # download fonts
return data # dictionary
def check_amp(model):
# Check PyTorch Automatic Mixed Precision (AMP) functionality. Return True on correct operation
from models.common import AutoShape, DetectMultiBackend
def amp_allclose(model, im):
# All close FP32 vs AMP results
m = AutoShape(model, verbose=False) # model
a = m(im).xywhn[0] # FP32 inference
m.amp = True
b = m(im).xywhn[0] # AMP inference
return a.shape == b.shape and torch.allclose(a, b, atol=0.1) # close to 10% absolute tolerance
prefix = colorstr('AMP: ')
device = next(model.parameters()).device # get model device
if device.type == 'cpu':
return False # AMP disabled on CPU
f = ROOT / 'data' / 'images' / 'bus.jpg' # image to check
im = f if f.exists() else 'https://ultralytics.com/images/bus.jpg' if check_online() else np.ones((640, 640, 3))
try:
assert amp_allclose(model, im) or amp_allclose(DetectMultiBackend('yolov5n.pt', device), im)
LOGGER.info(f'{prefix}checks passed ✅')
return True
except Exception:
help_url = 'https://github.com/ultralytics/yolov5/issues/7908'
LOGGER.warning(f'{prefix}checks failed �, disabling Automatic Mixed Precision. See {help_url}')
return False
def yaml_load(file='data.yaml'):
# Single-line safe yaml loading
with open(file, errors='ignore') as f:
return yaml.safe_load(f)
def yaml_save(file='data.yaml', data={}):
# Single-line safe yaml saving
with open(file, 'w') as f:
yaml.safe_dump({k: str(v) if isinstance(v, Path) else v for k, v in data.items()}, f, sort_keys=False)
def url2file(url):
# Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt
url = str(Path(url)).replace(':/', '://') # Pathlib turns :// -> :/
return Path(urllib.parse.unquote(url)).name.split('?')[0] # '%2F' to '/', split https://url.com/file.txt?auth
def download(url, dir='.', unzip=True, delete=True, curl=False, threads=1, retry=3):
# Multi-threaded file download and unzip function, used in data.yaml for autodownload
def download_one(url, dir):
# Download 1 file
success = True
f = dir / Path(url).name # filename
if Path(url).is_file(): # exists in current path
Path(url).rename(f) # move to dir
elif not f.exists():
LOGGER.info(f'Downloading {url} to {f}...')
for i in range(retry + 1):
if curl:
s = 'sS' if threads > 1 else '' # silent
r = os.system(f'curl -{s}L "{url}" -o "{f}" --retry 9 -C -') # curl download with retry, continue
success = r == 0
else:
torch.hub.download_url_to_file(url, f, progress=threads == 1) # torch download
success = f.is_file()
if success:
break
elif i < retry:
LOGGER.warning(f'Download failure, retrying {i + 1}/{retry} {url}...')
else:
LOGGER.warning(f'Failed to download {url}...')
if unzip and success and f.suffix in ('.zip', '.tar', '.gz'):
LOGGER.info(f'Unzipping {f}...')
if f.suffix == '.zip':
ZipFile(f).extractall(path=dir) # unzip
elif f.suffix == '.tar':
os.system(f'tar xf {f} --directory {f.parent}') # unzip
elif f.suffix == '.gz':
os.system(f'tar xfz {f} --directory {f.parent}') # unzip
if delete:
f.unlink() # remove zip
dir = Path(dir)
dir.mkdir(parents=True, exist_ok=True) # make directory
if threads > 1:
pool = ThreadPool(threads)
pool.imap(lambda x: download_one(*x), zip(url, repeat(dir))) # multi-threaded
pool.close()
pool.join()
else:
for u in [url] if isinstance(url, (str, Path)) else url:
download_one(u, dir)
def make_divisible(x, divisor):
# Returns nearest x divisible by divisor
if isinstance(divisor, torch.Tensor):
divisor = int(divisor.max()) # to int
return math.ceil(x / divisor) * divisor
def clean_str(s):
# Cleans a string by replacing special characters with underscore _
return re.sub(pattern="[|@#!¡·$€%&()=?¿^*;:,¨´><+]", repl="_", string=s)
def one_cycle(y1=0.0, y2=1.0, steps=100):
# lambda function for sinusoidal ramp from y1 to y2 https://arxiv.org/pdf/1812.01187.pdf
return lambda x: ((1 - math.cos(x * math.pi / steps)) / 2) * (y2 - y1) + y1
def colorstr(*input):
# Colors a string https://en.wikipedia.org/wiki/ANSI_escape_code, i.e. colorstr('blue', 'hello world')
*args, string = input if len(input) > 1 else ('blue', 'bold', input[0]) # color arguments, string
colors = {
'black': '\033[30m', # basic colors
'red': '\033[31m',
'green': '\033[32m',
'yellow': '\033[33m',
'blue': '\033[34m',
'magenta': '\033[35m',
'cyan': '\033[36m',
'white': '\033[37m',
'bright_black': '\033[90m', # bright colors
'bright_red': '\033[91m',
'bright_green': '\033[92m',
'bright_yellow': '\033[93m',
'bright_blue': '\033[94m',
'bright_magenta': '\033[95m',
'bright_cyan': '\033[96m',
'bright_white': '\033[97m',
'end': '\033[0m', # misc
'bold': '\033[1m',
'underline': '\033[4m'}
return ''.join(colors[x] for x in args) + f'{string}' + colors['end']
def labels_to_class_weights(labels, nc=80):
# Get class weights (inverse frequency) from training labels
if labels[0] is None: # no labels loaded
return torch.Tensor()
labels = np.concatenate(labels, 0) # labels.shape = (866643, 5) for COCO
classes = labels[:, 0].astype(int) # labels = [class xywh]
weights = np.bincount(classes, minlength=nc) # occurrences per class
# Prepend gridpoint count (for uCE training)
# gpi = ((320 / 32 * np.array([1, 2, 4])) ** 2 * 3).sum() # gridpoints per image
# weights = np.hstack([gpi * len(labels) - weights.sum() * 9, weights * 9]) ** 0.5 # prepend gridpoints to start
weights[weights == 0] = 1 # replace empty bins with 1
weights = 1 / weights # number of targets per class
weights /= weights.sum() # normalize
return torch.from_numpy(weights).float()
def labels_to_image_weights(labels, nc=80, class_weights=np.ones(80)):
# Produces image weights based on class_weights and image contents
# Usage: index = random.choices(range(n), weights=image_weights, k=1) # weighted image sample
class_counts = np.array([np.bincount(x[:, 0].astype(int), minlength=nc) for x in labels])
return (class_weights.reshape(1, nc) * class_counts).sum(1)
def coco80_to_coco91_class(): # converts 80-index (val2014) to 91-index (paper)
# https://tech.amikelive.com/node-718/what-object-categories-labels-are-in-coco-dataset/
# a = np.loadtxt('data/coco.names', dtype='str', delimiter='\n')
# b = np.loadtxt('data/coco_paper.names', dtype='str', delimiter='\n')
# x1 = [list(a[i] == b).index(True) + 1 for i in range(80)] # darknet to coco
# x2 = [list(b[i] == a).index(True) if any(b[i] == a) else None for i in range(91)] # coco to darknet
return [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90]
def xyxy2xywh(x):
# Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right
y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center
y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center
y[:, 2] = x[:, 2] - x[:, 0] # width
y[:, 3] = x[:, 3] - x[:, 1] # height
return y
def xywh2xyxy(x):
# Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right
y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
y[:, 0] = x[:, 0] - x[:, 2] / 2 # top left x
y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y
y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x
y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y
return y
def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0):
# Convert nx4 boxes from [x, y, w, h] normalized to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right
y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
y[:, 0] = w * (x[:, 0] - x[:, 2] / 2) + padw # top left x
y[:, 1] = h * (x[:, 1] - x[:, 3] / 2) + padh # top left y
y[:, 2] = w * (x[:, 0] + x[:, 2] / 2) + padw # bottom right x
y[:, 3] = h * (x[:, 1] + x[:, 3] / 2) + padh # bottom right y
return y
def xyxy2xywhn(x, w=640, h=640, clip=False, eps=0.0):
# Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] normalized where xy1=top-left, xy2=bottom-right
if clip:
clip_coords(x, (h - eps, w - eps)) # warning: inplace clip
y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
y[:, 0] = ((x[:, 0] + x[:, 2]) / 2) / w # x center
y[:, 1] = ((x[:, 1] + x[:, 3]) / 2) / h # y center
y[:, 2] = (x[:, 2] - x[:, 0]) / w # width
y[:, 3] = (x[:, 3] - x[:, 1]) / h # height
return y
def xyn2xy(x, w=640, h=640, padw=0, padh=0):
# Convert normalized segments into pixel segments, shape (n,2)
y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
y[:, 0] = w * x[:, 0] + padw # top left x
y[:, 1] = h * x[:, 1] + padh # top left y
return y
def segment2box(segment, width=640, height=640):
# Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy)
x, y = segment.T # segment xy
inside = (x >= 0) & (y >= 0) & (x <= width) & (y <= height)
x, y, = x[inside], y[inside]
return np.array([x.min(), y.min(), x.max(), y.max()]) if any(x) else np.zeros((1, 4)) # xyxy
def segments2boxes(segments):
# Convert segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh)
boxes = []
for s in segments:
x, y = s.T # segment xy
boxes.append([x.min(), y.min(), x.max(), y.max()]) # cls, xyxy
return xyxy2xywh(np.array(boxes)) # cls, xywh
def resample_segments(segments, n=1000):
# Up-sample an (n,2) segment
for i, s in enumerate(segments):
s = np.concatenate((s, s[0:1, :]), axis=0)
x = np.linspace(0, len(s) - 1, n)
xp = np.arange(len(s))
segments[i] = np.concatenate([np.interp(x, xp, s[:, i]) for i in range(2)]).reshape(2, -1).T # segment xy
return segments
def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None):
# Rescale coords (xyxy) from img1_shape to img0_shape
if ratio_pad is None: # calculate from img0_shape
gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1]) # gain = old / new
pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2 # wh padding
else:
gain = ratio_pad[0][0]
pad = ratio_pad[1]
coords[:, [0, 2]] -= pad[0] # x padding
coords[:, [1, 3]] -= pad[1] # y padding
coords[:, :4] /= gain
clip_coords(coords, img0_shape)
return coords
def clip_coords(boxes, shape):
# Clip bounding xyxy bounding boxes to image shape (height, width)
if isinstance(boxes, torch.Tensor): # faster individually
boxes[:, 0].clamp_(0, shape[1]) # x1
boxes[:, 1].clamp_(0, shape[0]) # y1
boxes[:, 2].clamp_(0, shape[1]) # x2
boxes[:, 3].clamp_(0, shape[0]) # y2
else: # np.array (faster grouped)
boxes[:, [0, 2]] = boxes[:, [0, 2]].clip(0, shape[1]) # x1, x2
boxes[:, [1, 3]] = boxes[:, [1, 3]].clip(0, shape[0]) # y1, y2
def non_max_suppression(prediction,
conf_thres=0.25,
iou_thres=0.45,
classes=None,
agnostic=False,
multi_label=False,
labels=(),
max_det=300):
"""Non-Maximum Suppression (NMS) on inference results to reject overlapping bounding boxes
Returns:
list of detections, on (n,6) tensor per image [xyxy, conf, cls]
"""
bs = prediction.shape[0] # batch size
nc = prediction.shape[2] - 5 # number of classes
xc = prediction[..., 4] > conf_thres # candidates
# Checks
assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'
assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'
# Settings
# min_wh = 2 # (pixels) minimum box width and height
max_wh = 7680 # (pixels) maximum box width and height
max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()
time_limit = 0.3 + 0.03 * bs # seconds to quit after
redundant = True # require redundant detections
multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)
merge = False # use merge-NMS
t = time.time()
output = [torch.zeros((0, 6), device=prediction.device)] * bs
for xi, x in enumerate(prediction): # image index, image inference
# Apply constraints
# x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height
x = x[xc[xi]] # confidence
# Cat apriori labels if autolabelling
if labels and len(labels[xi]):
lb = labels[xi]
v = torch.zeros((len(lb), nc + 5), device=x.device)
v[:, :4] = lb[:, 1:5] # box
v[:, 4] = 1.0 # conf
v[range(len(lb)), lb[:, 0].long() + 5] = 1.0 # cls
x = torch.cat((x, v), 0)
# If none remain process next image
if not x.shape[0]:
continue
# Compute conf
x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf
# Box (center x, center y, width, height) to (x1, y1, x2, y2)
box = xywh2xyxy(x[:, :4])
# Detections matrix nx6 (xyxy, conf, cls)
if multi_label:
i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T
x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)
else: # best class only
conf, j = x[:, 5:].max(1, keepdim=True)
x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]
# Filter by class
if classes is not None:
x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]
# Apply finite constraint
# if not torch.isfinite(x).all():
# x = x[torch.isfinite(x).all(1)]
# Check shape
n = x.shape[0] # number of boxes
if not n: # no boxes
continue
elif n > max_nms: # excess boxes
x = x[x[:, 4].argsort(descending=True)[:max_nms]] # sort by confidence
# Batched NMS
c = x[:, 5:6] * (0 if agnostic else max_wh) # classes
boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores
i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS
if i.shape[0] > max_det: # limit detections
i = i[:max_det]
if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)
# update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)
iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix
weights = iou * scores[None] # box weights
x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes
if redundant:
i = i[iou.sum(1) > 1] # require redundancy
output[xi] = x[i]
if (time.time() - t) > time_limit:
LOGGER.warning(f'WARNING: NMS time limit {time_limit:.3f}s exceeded')
break # time limit exceeded
return output
def strip_optimizer(f='best.pt', s=''): # from utils.general import *; strip_optimizer()
# Strip optimizer from 'f' to finalize training, optionally save as 's'
x = torch.load(f, map_location=torch.device('cpu'))
if x.get('ema'):
x['model'] = x['ema'] # replace model with ema
for k in 'optimizer', 'best_fitness', 'wandb_id', 'ema', 'updates': # keys
x[k] = None
x['epoch'] = -1
x['model'].half() # to FP16
for p in x['model'].parameters():
p.requires_grad = False
torch.save(x, s or f)
mb = os.path.getsize(s or f) / 1E6 # filesize
LOGGER.info(f"Optimizer stripped from {f},{f' saved as {s},' if s else ''} {mb:.1f}MB")
def print_mutation(results, hyp, save_dir, bucket, prefix=colorstr('evolve: ')):
evolve_csv = save_dir / 'evolve.csv'
evolve_yaml = save_dir / 'hyp_evolve.yaml'
keys = ('metrics/precision', 'metrics/recall', 'metrics/mAP_0.5', 'metrics/mAP_0.5:0.95', 'val/box_loss',
'val/obj_loss', 'val/cls_loss') + tuple(hyp.keys()) # [results + hyps]
keys = tuple(x.strip() for x in keys)
vals = results + tuple(hyp.values())
n = len(keys)
# Download (optional)
if bucket:
url = f'gs://{bucket}/evolve.csv'
if gsutil_getsize(url) > (evolve_csv.stat().st_size if evolve_csv.exists() else 0):
os.system(f'gsutil cp {url} {save_dir}') # download evolve.csv if larger than local
# Log to evolve.csv
s = '' if evolve_csv.exists() else (('%20s,' * n % keys).rstrip(',') + '\n') # add header
with open(evolve_csv, 'a') as f:
f.write(s + ('%20.5g,' * n % vals).rstrip(',') + '\n')
# Save yaml
with open(evolve_yaml, 'w') as f:
data = pd.read_csv(evolve_csv)
data = data.rename(columns=lambda x: x.strip()) # strip keys
i = np.argmax(fitness(data.values[:, :4])) #
generations = len(data)
f.write('# YOLOv5 Hyperparameter Evolution Results\n' + f'# Best generation: {i}\n' +
f'# Last generation: {generations - 1}\n' + '# ' + ', '.join(f'{x.strip():>20s}' for x in keys[:7]) +
'\n' + '# ' + ', '.join(f'{x:>20.5g}' for x in data.values[i, :7]) + '\n\n')
yaml.safe_dump(data.loc[i][7:].to_dict(), f, sort_keys=False)
# Print to screen
LOGGER.info(prefix + f'{generations} generations finished, current result:\n' + prefix +
', '.join(f'{x.strip():>20s}' for x in keys) + '\n' + prefix + ', '.join(f'{x:20.5g}'
for x in vals) + '\n\n')
if bucket:
os.system(f'gsutil cp {evolve_csv} {evolve_yaml} gs://{bucket}') # upload
def apply_classifier(x, model, img, im0):
# Apply a second stage classifier to YOLO outputs
# Example model = torchvision.models.__dict__['efficientnet_b0'](pretrained=True).to(device).eval()
im0 = [im0] if isinstance(im0, np.ndarray) else im0
for i, d in enumerate(x): # per image
if d is not None and len(d):
d = d.clone()
# Reshape and pad cutouts
b = xyxy2xywh(d[:, :4]) # boxes
b[:, 2:] = b[:, 2:].max(1)[0].unsqueeze(1) # rectangle to square
b[:, 2:] = b[:, 2:] * 1.3 + 30 # pad
d[:, :4] = xywh2xyxy(b).long()
# Rescale boxes from img_size to im0 size
scale_coords(img.shape[2:], d[:, :4], im0[i].shape)
# Classes
pred_cls1 = d[:, 5].long()
ims = []
for a in d:
cutout = im0[i][int(a[1]):int(a[3]), int(a[0]):int(a[2])]
im = cv2.resize(cutout, (224, 224)) # BGR
im = im[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416
im = np.ascontiguousarray(im, dtype=np.float32) # uint8 to float32
im /= 255 # 0 - 255 to 0.0 - 1.0
ims.append(im)
pred_cls2 = model(torch.Tensor(ims).to(d.device)).argmax(1) # classifier prediction
x[i] = x[i][pred_cls1 == pred_cls2] # retain matching class detections
return x
def increment_path(path, exist_ok=False, sep='', mkdir=False):
# Increment file or directory path, i.e. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.
path = Path(path) # os-agnostic
if path.exists() and not exist_ok:
path, suffix = (path.with_suffix(''), path.suffix) if path.is_file() else (path, '')
# Method 1
for n in range(2, 9999):
p = f'{path}{sep}{n}{suffix}' # increment path
if not os.path.exists(p): #
break
path = Path(p)
# Method 2 (deprecated)
# dirs = glob.glob(f"{path}{sep}*") # similar paths
# matches = [re.search(rf"{path.stem}{sep}(\d+)", d) for d in dirs]
# i = [int(m.groups()[0]) for m in matches if m] # indices
# n = max(i) + 1 if i else 2 # increment number
# path = Path(f"{path}{sep}{n}{suffix}") # increment path
if mkdir:
path.mkdir(parents=True, exist_ok=True) # make directory
return path
# OpenCV Chinese-friendly functions ------------------------------------------------------------------------------------
imshow_ = cv2.imshow # copy to avoid recursion errors
def imread(path, flags=cv2.IMREAD_COLOR):
return cv2.imdecode(np.fromfile(path, np.uint8), flags)
def imwrite(path, im):
try:
cv2.imencode(Path(path).suffix, im)[1].tofile(path)
return True
except Exception:
return False
def imshow(path, im):
imshow_(path.encode('unicode_escape').decode(), im)
cv2.imread, cv2.imwrite, cv2.imshow = imread, imwrite, imshow # redefine
# Variables ------------------------------------------------------------------------------------------------------------
NCOLS = 0 if is_docker() else shutil.get_terminal_size().columns # terminal window size for tqdm
| 43,480 | Python | .py | 848 | 43.726415 | 134 | 0.601556 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,518 | dataloaders.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/dataloaders.py | # YOLOv5 üöÄ by Ultralytics, GPL-3.0 license
"""
Dataloaders and dataset utils
"""
import contextlib
import glob
import hashlib
import json
import math
import os
import random
import shutil
import time
from itertools import repeat
from multiprocessing.pool import Pool, ThreadPool
from pathlib import Path
from threading import Thread
from urllib.parse import urlparse
from zipfile import ZipFile
import numpy as np
import torch
import torch.nn.functional as F
import torchvision
import yaml
from PIL import ExifTags, Image, ImageOps
from torch.utils.data import DataLoader, Dataset, dataloader, distributed
from tqdm import tqdm
from utils.augmentations import (Albumentations, augment_hsv, classify_albumentations, classify_transforms, copy_paste,
letterbox, mixup, random_perspective)
from utils.general import (DATASETS_DIR, LOGGER, NUM_THREADS, check_dataset, check_requirements, check_yaml, clean_str,
cv2, is_colab, is_kaggle, segments2boxes, xyn2xy, xywh2xyxy, xywhn2xyxy, xyxy2xywhn)
from utils.torch_utils import torch_distributed_zero_first
# Parameters
HELP_URL = 'https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data'
IMG_FORMATS = 'bmp', 'dng', 'jpeg', 'jpg', 'mpo', 'png', 'tif', 'tiff', 'webp' # include image suffixes
VID_FORMATS = 'asf', 'avi', 'gif', 'm4v', 'mkv', 'mov', 'mp4', 'mpeg', 'mpg', 'ts', 'wmv' # include video suffixes
BAR_FORMAT = '{l_bar}{bar:10}{r_bar}{bar:-10b}' # tqdm bar format
LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1)) # https://pytorch.org/docs/stable/elastic/run.html
# Get orientation exif tag
for orientation in ExifTags.TAGS.keys():
if ExifTags.TAGS[orientation] == 'Orientation':
break
def get_hash(paths):
# Returns a single hash value of a list of paths (files or dirs)
size = sum(os.path.getsize(p) for p in paths if os.path.exists(p)) # sizes
h = hashlib.md5(str(size).encode()) # hash sizes
h.update(''.join(paths).encode()) # hash paths
return h.hexdigest() # return hash
def exif_size(img):
# Returns exif-corrected PIL size
s = img.size # (width, height)
with contextlib.suppress(Exception):
rotation = dict(img._getexif().items())[orientation]
if rotation in [6, 8]: # rotation 270 or 90
s = (s[1], s[0])
return s
def exif_transpose(image):
"""
Transpose a PIL image accordingly if it has an EXIF Orientation tag.
Inplace version of https://github.com/python-pillow/Pillow/blob/master/src/PIL/ImageOps.py exif_transpose()
:param image: The image to transpose.
:return: An image.
"""
exif = image.getexif()
orientation = exif.get(0x0112, 1) # default 1
if orientation > 1:
method = {
2: Image.FLIP_LEFT_RIGHT,
3: Image.ROTATE_180,
4: Image.FLIP_TOP_BOTTOM,
5: Image.TRANSPOSE,
6: Image.ROTATE_270,
7: Image.TRANSVERSE,
8: Image.ROTATE_90,}.get(orientation)
if method is not None:
image = image.transpose(method)
del exif[0x0112]
image.info["exif"] = exif.tobytes()
return image
def seed_worker(worker_id):
# Set dataloader worker seed https://pytorch.org/docs/stable/notes/randomness.html#dataloader
worker_seed = torch.initial_seed() % 2 ** 32
np.random.seed(worker_seed)
random.seed(worker_seed)
def create_dataloader(path,
imgsz,
batch_size,
stride,
single_cls=False,
hyp=None,
augment=False,
cache=False,
pad=0.0,
rect=False,
rank=-1,
workers=8,
image_weights=False,
quad=False,
prefix='',
shuffle=False):
if rect and shuffle:
LOGGER.warning('WARNING: --rect is incompatible with DataLoader shuffle, setting shuffle=False')
shuffle = False
with torch_distributed_zero_first(rank): # init dataset *.cache only once if DDP
dataset = LoadImagesAndLabels(
path,
imgsz,
batch_size,
augment=augment, # augmentation
hyp=hyp, # hyperparameters
rect=rect, # rectangular batches
cache_images=cache,
single_cls=single_cls,
stride=int(stride),
pad=pad,
image_weights=image_weights,
prefix=prefix)
batch_size = min(batch_size, len(dataset))
nd = torch.cuda.device_count() # number of CUDA devices
nw = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, workers]) # number of workers
sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)
loader = DataLoader if image_weights else InfiniteDataLoader # only DataLoader allows for attribute updates
generator = torch.Generator()
generator.manual_seed(0)
return loader(dataset,
batch_size=batch_size,
shuffle=shuffle and sampler is None,
num_workers=nw,
sampler=sampler,
pin_memory=True,
collate_fn=LoadImagesAndLabels.collate_fn4 if quad else LoadImagesAndLabels.collate_fn,
worker_init_fn=seed_worker,
generator=generator), dataset
class InfiniteDataLoader(dataloader.DataLoader):
""" Dataloader that reuses workers
Uses same syntax as vanilla DataLoader
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
object.__setattr__(self, 'batch_sampler', _RepeatSampler(self.batch_sampler))
self.iterator = super().__iter__()
def __len__(self):
return len(self.batch_sampler.sampler)
def __iter__(self):
for _ in range(len(self)):
yield next(self.iterator)
class _RepeatSampler:
""" Sampler that repeats forever
Args:
sampler (Sampler)
"""
def __init__(self, sampler):
self.sampler = sampler
def __iter__(self):
while True:
yield from iter(self.sampler)
class LoadImages:
# YOLOv5 image/video dataloader, i.e. `python detect.py --source image.jpg/vid.mp4`
def __init__(self, path, img_size=640, stride=32, auto=True):
files = []
for p in sorted(path) if isinstance(path, (list, tuple)) else [path]:
p = str(Path(p).resolve())
if '*' in p:
files.extend(sorted(glob.glob(p, recursive=True))) # glob
elif os.path.isdir(p):
files.extend(sorted(glob.glob(os.path.join(p, '*.*')))) # dir
elif os.path.isfile(p):
files.append(p) # files
else:
raise FileNotFoundError(f'{p} does not exist')
images = [x for x in files if x.split('.')[-1].lower() in IMG_FORMATS]
videos = [x for x in files if x.split('.')[-1].lower() in VID_FORMATS]
ni, nv = len(images), len(videos)
self.img_size = img_size
self.stride = stride
self.files = images + videos
self.nf = ni + nv # number of files
self.video_flag = [False] * ni + [True] * nv
self.mode = 'image'
self.auto = auto
if any(videos):
self.new_video(videos[0]) # new video
else:
self.cap = None
assert self.nf > 0, f'No images or videos found in {p}. ' \
f'Supported formats are:\nimages: {IMG_FORMATS}\nvideos: {VID_FORMATS}'
def __iter__(self):
self.count = 0
return self
def __next__(self):
if self.count == self.nf:
raise StopIteration
path = self.files[self.count]
if self.video_flag[self.count]:
# Read video
self.mode = 'video'
ret_val, img0 = self.cap.read()
while not ret_val:
self.count += 1
self.cap.release()
if self.count == self.nf: # last video
raise StopIteration
path = self.files[self.count]
self.new_video(path)
ret_val, img0 = self.cap.read()
self.frame += 1
s = f'video {self.count + 1}/{self.nf} ({self.frame}/{self.frames}) {path}: '
else:
# Read image
self.count += 1
img0 = cv2.imread(path) # BGR
assert img0 is not None, f'Image Not Found {path}'
s = f'image {self.count}/{self.nf} {path}: '
# Padded resize
img = letterbox(img0, self.img_size, stride=self.stride, auto=self.auto)[0]
# Convert
img = img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB
img = np.ascontiguousarray(img)
return path, img, img0, self.cap, s
def new_video(self, path):
self.frame = 0
self.cap = cv2.VideoCapture(path)
self.frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
def __len__(self):
return self.nf # number of files
class LoadWebcam: # for inference
# YOLOv5 local webcam dataloader, i.e. `python detect.py --source 0`
def __init__(self, pipe='0', img_size=640, stride=32):
self.img_size = img_size
self.stride = stride
self.pipe = eval(pipe) if pipe.isnumeric() else pipe
self.cap = cv2.VideoCapture(self.pipe) # video capture object
self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 3) # set buffer size
def __iter__(self):
self.count = -1
return self
def __next__(self):
self.count += 1
if cv2.waitKey(1) == ord('q'): # q to quit
self.cap.release()
cv2.destroyAllWindows()
raise StopIteration
# Read frame
ret_val, img0 = self.cap.read()
img0 = cv2.flip(img0, 1) # flip left-right
# Print
assert ret_val, f'Camera Error {self.pipe}'
img_path = 'webcam.jpg'
s = f'webcam {self.count}: '
# Padded resize
img = letterbox(img0, self.img_size, stride=self.stride)[0]
# Convert
img = img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB
img = np.ascontiguousarray(img)
return img_path, img, img0, None, s
def __len__(self):
return 0
class LoadStreams:
# YOLOv5 streamloader, i.e. `python detect.py --source 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP streams`
def __init__(self, sources='streams.txt', img_size=640, stride=32, auto=True):
self.mode = 'stream'
self.img_size = img_size
self.stride = stride
if os.path.isfile(sources):
with open(sources) as f:
sources = [x.strip() for x in f.read().strip().splitlines() if len(x.strip())]
else:
sources = [sources]
n = len(sources)
self.imgs, self.fps, self.frames, self.threads = [None] * n, [0] * n, [0] * n, [None] * n
self.sources = [clean_str(x) for x in sources] # clean source names for later
self.auto = auto
for i, s in enumerate(sources): # index, source
# Start thread to read frames from video stream
st = f'{i + 1}/{n}: {s}... '
if urlparse(s).hostname in ('www.youtube.com', 'youtube.com', 'youtu.be'): # if source is YouTube video
check_requirements(('pafy', 'youtube_dl==2020.12.2'))
import pafy
s = pafy.new(s).getbest(preftype="mp4").url # YouTube URL
s = eval(s) if s.isnumeric() else s # i.e. s = '0' local webcam
if s == 0:
assert not is_colab(), '--source 0 webcam unsupported on Colab. Rerun command in a local environment.'
assert not is_kaggle(), '--source 0 webcam unsupported on Kaggle. Rerun command in a local environment.'
cap = cv2.VideoCapture(s)
assert cap.isOpened(), f'{st}Failed to open {s}'
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS) # warning: may return 0 or nan
self.frames[i] = max(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), 0) or float('inf') # infinite stream fallback
self.fps[i] = max((fps if math.isfinite(fps) else 0) % 100, 0) or 30 # 30 FPS fallback
_, self.imgs[i] = cap.read() # guarantee first frame
self.threads[i] = Thread(target=self.update, args=([i, cap, s]), daemon=True)
LOGGER.info(f"{st} Success ({self.frames[i]} frames {w}x{h} at {self.fps[i]:.2f} FPS)")
self.threads[i].start()
LOGGER.info('') # newline
# check for common shapes
s = np.stack([letterbox(x, self.img_size, stride=self.stride, auto=self.auto)[0].shape for x in self.imgs])
self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal
if not self.rect:
LOGGER.warning('WARNING: Stream shapes differ. For optimal performance supply similarly-shaped streams.')
def update(self, i, cap, stream):
# Read stream `i` frames in daemon thread
n, f, read = 0, self.frames[i], 1 # frame number, frame array, inference every 'read' frame
while cap.isOpened() and n < f:
n += 1
# _, self.imgs[index] = cap.read()
cap.grab()
if n % read == 0:
success, im = cap.retrieve()
if success:
self.imgs[i] = im
else:
LOGGER.warning('WARNING: Video stream unresponsive, please check your IP camera connection.')
self.imgs[i] = np.zeros_like(self.imgs[i])
cap.open(stream) # re-open stream if signal was lost
time.sleep(0.0) # wait time
def __iter__(self):
self.count = -1
return self
def __next__(self):
self.count += 1
if not all(x.is_alive() for x in self.threads) or cv2.waitKey(1) == ord('q'): # q to quit
cv2.destroyAllWindows()
raise StopIteration
# Letterbox
img0 = self.imgs.copy()
img = [letterbox(x, self.img_size, stride=self.stride, auto=self.rect and self.auto)[0] for x in img0]
# Stack
img = np.stack(img, 0)
# Convert
img = img[..., ::-1].transpose((0, 3, 1, 2)) # BGR to RGB, BHWC to BCHW
img = np.ascontiguousarray(img)
return self.sources, img, img0, None, ''
def __len__(self):
return len(self.sources) # 1E12 frames = 32 streams at 30 FPS for 30 years
def img2label_paths(img_paths):
# Define label paths as a function of image paths
sa, sb = f'{os.sep}images{os.sep}', f'{os.sep}labels{os.sep}' # /images/, /labels/ substrings
return [sb.join(x.rsplit(sa, 1)).rsplit('.', 1)[0] + '.txt' for x in img_paths]
class LoadImagesAndLabels(Dataset):
# YOLOv5 train_loader/val_loader, loads images and labels for training and validation
cache_version = 0.6 # dataset labels *.cache version
rand_interp_methods = [cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4]
def __init__(self,
path,
img_size=640,
batch_size=16,
augment=False,
hyp=None,
rect=False,
image_weights=False,
cache_images=False,
single_cls=False,
stride=32,
pad=0.0,
prefix=''):
self.img_size = img_size
self.augment = augment
self.hyp = hyp
self.image_weights = image_weights
self.rect = False if image_weights else rect
self.mosaic = self.augment and not self.rect # load 4 images at a time into a mosaic (only during training)
self.mosaic_border = [-img_size // 2, -img_size // 2]
self.stride = stride
self.path = path
self.albumentations = Albumentations() if augment else None
try:
f = [] # image files
for p in path if isinstance(path, list) else [path]:
p = Path(p) # os-agnostic
if p.is_dir(): # dir
f += glob.glob(str(p / '**' / '*.*'), recursive=True)
# f = list(p.rglob('*.*')) # pathlib
elif p.is_file(): # file
with open(p) as t:
t = t.read().strip().splitlines()
parent = str(p.parent) + os.sep
f += [x.replace('./', parent) if x.startswith('./') else x for x in t] # local to global path
# f += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib)
else:
raise FileNotFoundError(f'{prefix}{p} does not exist')
self.im_files = sorted(x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in IMG_FORMATS)
# self.img_files = sorted([x for x in f if x.suffix[1:].lower() in IMG_FORMATS]) # pathlib
assert self.im_files, f'{prefix}No images found'
except Exception as e:
raise Exception(f'{prefix}Error loading data from {path}: {e}\nSee {HELP_URL}')
# Check cache
self.label_files = img2label_paths(self.im_files) # labels
cache_path = (p if p.is_file() else Path(self.label_files[0]).parent).with_suffix('.cache')
try:
cache, exists = np.load(cache_path, allow_pickle=True).item(), True # load dict
assert cache['version'] == self.cache_version # matches current version
assert cache['hash'] == get_hash(self.label_files + self.im_files) # identical hash
except Exception:
cache, exists = self.cache_labels(cache_path, prefix), False # run cache ops
# Display cache
nf, nm, ne, nc, n = cache.pop('results') # found, missing, empty, corrupt, total
if exists and LOCAL_RANK in {-1, 0}:
d = f"Scanning '{cache_path}' images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupt"
tqdm(None, desc=prefix + d, total=n, initial=n, bar_format=BAR_FORMAT) # display cache results
if cache['msgs']:
LOGGER.info('\n'.join(cache['msgs'])) # display warnings
assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {HELP_URL}'
# Read cache
[cache.pop(k) for k in ('hash', 'version', 'msgs')] # remove items
labels, shapes, self.segments = zip(*cache.values())
self.labels = list(labels)
self.shapes = np.array(shapes)
self.im_files = list(cache.keys()) # update
self.label_files = img2label_paths(cache.keys()) # update
n = len(shapes) # number of images
'''
Flat White 2023.1.13
AttributeError: module 'numpy' has no attribute 'int'
np.int已弃用 需要修改为np.int64
https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
'''
bi = np.floor(np.arange(n) / batch_size).astype(np.int64) # batch index
# 以下为修改前
# bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index
nb = bi[-1] + 1 # number of batches
self.batch = bi # batch index of image
self.n = n
self.indices = range(n)
# Update labels
include_class = [] # filter labels to include only these classes (optional)
include_class_array = np.array(include_class).reshape(1, -1)
for i, (label, segment) in enumerate(zip(self.labels, self.segments)):
if include_class:
j = (label[:, 0:1] == include_class_array).any(1)
self.labels[i] = label[j]
if segment:
self.segments[i] = segment[j]
if single_cls: # single-class training, merge all classes into 0
self.labels[i][:, 0] = 0
if segment:
self.segments[i][:, 0] = 0
# Rectangular Training
if self.rect:
# Sort by aspect ratio
s = self.shapes # wh
ar = s[:, 1] / s[:, 0] # aspect ratio
irect = ar.argsort()
self.im_files = [self.im_files[i] for i in irect]
self.label_files = [self.label_files[i] for i in irect]
self.labels = [self.labels[i] for i in irect]
self.shapes = s[irect] # wh
ar = ar[irect]
# Set training image shapes
shapes = [[1, 1]] * nb
for i in range(nb):
ari = ar[bi == i]
mini, maxi = ari.min(), ari.max()
if maxi < 1:
shapes[i] = [maxi, 1]
elif mini > 1:
shapes[i] = [1, 1 / mini]
'''
Flat White 2023.1.13
AttributeError: module 'numpy' has no attribute 'int'
np.int已弃用 需要修改为np.int64
https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
'''
self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int64) * stride
# 以下为修改前
# self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int) * stride
# Cache images into RAM/disk for faster training (WARNING: large datasets may exceed system resources)
self.ims = [None] * n
self.npy_files = [Path(f).with_suffix('.npy') for f in self.im_files]
if cache_images:
gb = 0 # Gigabytes of cached images
self.im_hw0, self.im_hw = [None] * n, [None] * n
fcn = self.cache_images_to_disk if cache_images == 'disk' else self.load_image
results = ThreadPool(NUM_THREADS).imap(fcn, range(n))
pbar = tqdm(enumerate(results), total=n, bar_format=BAR_FORMAT, disable=LOCAL_RANK > 0)
for i, x in pbar:
if cache_images == 'disk':
gb += self.npy_files[i].stat().st_size
else: # 'ram'
self.ims[i], self.im_hw0[i], self.im_hw[i] = x # im, hw_orig, hw_resized = load_image(self, i)
gb += self.ims[i].nbytes
pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB {cache_images})'
pbar.close()
def cache_labels(self, path=Path('./labels.cache'), prefix=''):
# Cache dataset labels, check images and read shapes
x = {} # dict
nm, nf, ne, nc, msgs = 0, 0, 0, 0, [] # number missing, found, empty, corrupt, messages
desc = f"{prefix}Scanning '{path.parent / path.stem}' images and labels..."
with Pool(NUM_THREADS) as pool:
pbar = tqdm(pool.imap(verify_image_label, zip(self.im_files, self.label_files, repeat(prefix))),
desc=desc,
total=len(self.im_files),
bar_format=BAR_FORMAT)
for im_file, lb, shape, segments, nm_f, nf_f, ne_f, nc_f, msg in pbar:
nm += nm_f
nf += nf_f
ne += ne_f
nc += nc_f
if im_file:
x[im_file] = [lb, shape, segments]
if msg:
msgs.append(msg)
pbar.desc = f"{desc}{nf} found, {nm} missing, {ne} empty, {nc} corrupt"
pbar.close()
if msgs:
LOGGER.info('\n'.join(msgs))
if nf == 0:
LOGGER.warning(f'{prefix}WARNING: No labels found in {path}. See {HELP_URL}')
x['hash'] = get_hash(self.label_files + self.im_files)
x['results'] = nf, nm, ne, nc, len(self.im_files)
x['msgs'] = msgs # warnings
x['version'] = self.cache_version # cache version
try:
np.save(path, x) # save cache for next time
path.with_suffix('.cache.npy').rename(path) # remove .npy suffix
LOGGER.info(f'{prefix}New cache created: {path}')
except Exception as e:
LOGGER.warning(f'{prefix}WARNING: Cache directory {path.parent} is not writeable: {e}') # not writeable
return x
def __len__(self):
return len(self.im_files)
# def __iter__(self):
# self.count = -1
# print('ran dataset iter')
# #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF)
# return self
def __getitem__(self, index):
index = self.indices[index] # linear, shuffled, or image_weights
hyp = self.hyp
mosaic = self.mosaic and random.random() < hyp['mosaic']
if mosaic:
# Load mosaic
img, labels = self.load_mosaic(index)
shapes = None
# MixUp augmentation
if random.random() < hyp['mixup']:
img, labels = mixup(img, labels, *self.load_mosaic(random.randint(0, self.n - 1)))
else:
# Load image
img, (h0, w0), (h, w) = self.load_image(index)
# Letterbox
shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size # final letterboxed shape
img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)
shapes = (h0, w0), ((h / h0, w / w0), pad) # for COCO mAP rescaling
labels = self.labels[index].copy()
if labels.size: # normalized xywh to pixel xyxy format
labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1])
if self.augment:
img, labels = random_perspective(img,
labels,
degrees=hyp['degrees'],
translate=hyp['translate'],
scale=hyp['scale'],
shear=hyp['shear'],
perspective=hyp['perspective'])
nl = len(labels) # number of labels
if nl:
labels[:, 1:5] = xyxy2xywhn(labels[:, 1:5], w=img.shape[1], h=img.shape[0], clip=True, eps=1E-3)
if self.augment:
# Albumentations
img, labels = self.albumentations(img, labels)
nl = len(labels) # update after albumentations
# HSV color-space
augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v'])
# Flip up-down
if random.random() < hyp['flipud']:
img = np.flipud(img)
if nl:
labels[:, 2] = 1 - labels[:, 2]
# Flip left-right
if random.random() < hyp['fliplr']:
img = np.fliplr(img)
if nl:
labels[:, 1] = 1 - labels[:, 1]
# Cutouts
# labels = cutout(img, labels, p=0.5)
# nl = len(labels) # update after cutout
labels_out = torch.zeros((nl, 6))
if nl:
labels_out[:, 1:] = torch.from_numpy(labels)
# Convert
img = img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB
img = np.ascontiguousarray(img)
return torch.from_numpy(img), labels_out, self.im_files[index], shapes
def load_image(self, i):
# Loads 1 image from dataset index 'i', returns (im, original hw, resized hw)
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i],
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
assert im is not None, f'Image Not Found {f}'
h0, w0 = im.shape[:2] # orig hw
r = self.img_size / max(h0, w0) # ratio
if r != 1: # if sizes are not equal
interp = cv2.INTER_LINEAR if (self.augment or r > 1) else cv2.INTER_AREA
im = cv2.resize(im, (int(w0 * r), int(h0 * r)), interpolation=interp)
return im, (h0, w0), im.shape[:2] # im, hw_original, hw_resized
return self.ims[i], self.im_hw0[i], self.im_hw[i] # im, hw_original, hw_resized
def cache_images_to_disk(self, i):
# Saves an image as an *.npy file for faster loading
f = self.npy_files[i]
if not f.exists():
np.save(f.as_posix(), cv2.imread(self.im_files[i]))
def load_mosaic(self, index):
# YOLOv5 4-mosaic loader. Loads 1 image + 3 random images into a 4-image mosaic
labels4, segments4 = [], []
s = self.img_size
yc, xc = (int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border) # mosaic center x, y
indices = [index] + random.choices(self.indices, k=3) # 3 additional image indices
random.shuffle(indices)
for i, index in enumerate(indices):
# Load image
img, _, (h, w) = self.load_image(index)
# place img in img4
if i == 0: # top left
img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles
x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image)
x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image)
elif i == 1: # top right
x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
elif i == 2: # bottom left
x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)
elif i == 3: # bottom right
x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)
img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]
padw = x1a - x1b
padh = y1a - y1b
# Labels
labels, segments = self.labels[index].copy(), self.segments[index].copy()
if labels.size:
labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) # normalized xywh to pixel xyxy format
segments = [xyn2xy(x, w, h, padw, padh) for x in segments]
labels4.append(labels)
segments4.extend(segments)
# Concat/clip labels
labels4 = np.concatenate(labels4, 0)
for x in (labels4[:, 1:], *segments4):
np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective()
# img4, labels4 = replicate(img4, labels4) # replicate
# Augment
img4, labels4, segments4 = copy_paste(img4, labels4, segments4, p=self.hyp['copy_paste'])
img4, labels4 = random_perspective(img4,
labels4,
segments4,
degrees=self.hyp['degrees'],
translate=self.hyp['translate'],
scale=self.hyp['scale'],
shear=self.hyp['shear'],
perspective=self.hyp['perspective'],
border=self.mosaic_border) # border to remove
return img4, labels4
def load_mosaic9(self, index):
# YOLOv5 9-mosaic loader. Loads 1 image + 8 random images into a 9-image mosaic
labels9, segments9 = [], []
s = self.img_size
indices = [index] + random.choices(self.indices, k=8) # 8 additional image indices
random.shuffle(indices)
hp, wp = -1, -1 # height, width previous
for i, index in enumerate(indices):
# Load image
img, _, (h, w) = self.load_image(index)
# place img in img9
if i == 0: # center
img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles
h0, w0 = h, w
c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates
elif i == 1: # top
c = s, s - h, s + w, s
elif i == 2: # top right
c = s + wp, s - h, s + wp + w, s
elif i == 3: # right
c = s + w0, s, s + w0 + w, s + h
elif i == 4: # bottom right
c = s + w0, s + hp, s + w0 + w, s + hp + h
elif i == 5: # bottom
c = s + w0 - w, s + h0, s + w0, s + h0 + h
elif i == 6: # bottom left
c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h
elif i == 7: # left
c = s - w, s + h0 - h, s, s + h0
elif i == 8: # top left
c = s - w, s + h0 - hp - h, s, s + h0 - hp
padx, pady = c[:2]
x1, y1, x2, y2 = (max(x, 0) for x in c) # allocate coords
# Labels
labels, segments = self.labels[index].copy(), self.segments[index].copy()
if labels.size:
labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady) # normalized xywh to pixel xyxy format
segments = [xyn2xy(x, w, h, padx, pady) for x in segments]
labels9.append(labels)
segments9.extend(segments)
# Image
img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:] # img9[ymin:ymax, xmin:xmax]
hp, wp = h, w # height, width previous
# Offset
yc, xc = (int(random.uniform(0, s)) for _ in self.mosaic_border) # mosaic center x, y
img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s]
# Concat/clip labels
labels9 = np.concatenate(labels9, 0)
labels9[:, [1, 3]] -= xc
labels9[:, [2, 4]] -= yc
c = np.array([xc, yc]) # centers
segments9 = [x - c for x in segments9]
for x in (labels9[:, 1:], *segments9):
np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective()
# img9, labels9 = replicate(img9, labels9) # replicate
# Augment
img9, labels9 = random_perspective(img9,
labels9,
segments9,
degrees=self.hyp['degrees'],
translate=self.hyp['translate'],
scale=self.hyp['scale'],
shear=self.hyp['shear'],
perspective=self.hyp['perspective'],
border=self.mosaic_border) # border to remove
return img9, labels9
@staticmethod
def collate_fn(batch):
im, label, path, shapes = zip(*batch) # transposed
for i, lb in enumerate(label):
lb[:, 0] = i # add target image index for build_targets()
return torch.stack(im, 0), torch.cat(label, 0), path, shapes
@staticmethod
def collate_fn4(batch):
img, label, path, shapes = zip(*batch) # transposed
n = len(shapes) // 4
im4, label4, path4, shapes4 = [], [], path[:n], shapes[:n]
ho = torch.tensor([[0.0, 0, 0, 1, 0, 0]])
wo = torch.tensor([[0.0, 0, 1, 0, 0, 0]])
s = torch.tensor([[1, 1, 0.5, 0.5, 0.5, 0.5]]) # scale
for i in range(n): # zidane torch.zeros(16,3,720,1280) # BCHW
i *= 4
if random.random() < 0.5:
im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2.0, mode='bilinear',
align_corners=False)[0].type(img[i].type())
lb = label[i]
else:
im = torch.cat((torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2)
lb = torch.cat((label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s
im4.append(im)
label4.append(lb)
for i, lb in enumerate(label4):
lb[:, 0] = i # add target image index for build_targets()
return torch.stack(im4, 0), torch.cat(label4, 0), path4, shapes4
# Ancillary functions --------------------------------------------------------------------------------------------------
def flatten_recursive(path=DATASETS_DIR / 'coco128'):
# Flatten a recursive directory by bringing all files to top level
new_path = Path(f'{str(path)}_flat')
if os.path.exists(new_path):
shutil.rmtree(new_path) # delete output folder
os.makedirs(new_path) # make new output folder
for file in tqdm(glob.glob(f'{str(Path(path))}/**/*.*', recursive=True)):
shutil.copyfile(file, new_path / Path(file).name)
def extract_boxes(path=DATASETS_DIR / 'coco128'): # from utils.dataloaders import *; extract_boxes()
# Convert detection dataset into classification dataset, with one directory per class
path = Path(path) # images dir
shutil.rmtree(path / 'classification') if (path / 'classification').is_dir() else None # remove existing
files = list(path.rglob('*.*'))
n = len(files) # number of files
for im_file in tqdm(files, total=n):
if im_file.suffix[1:] in IMG_FORMATS:
# image
im = cv2.imread(str(im_file))[..., ::-1] # BGR to RGB
h, w = im.shape[:2]
# labels
lb_file = Path(img2label_paths([str(im_file)])[0])
if Path(lb_file).exists():
with open(lb_file) as f:
lb = np.array([x.split() for x in f.read().strip().splitlines()], dtype=np.float32) # labels
for j, x in enumerate(lb):
c = int(x[0]) # class
f = (path / 'classifier') / f'{c}' / f'{path.stem}_{im_file.stem}_{j}.jpg' # new filename
if not f.parent.is_dir():
f.parent.mkdir(parents=True)
b = x[1:] * [w, h, w, h] # box
# b[2:] = b[2:].max() # rectangle to square
b[2:] = b[2:] * 1.2 + 3 # pad
'''
Flat White 2023.1.13
AttributeError: module 'numpy' has no attribute 'int'
np.int已弃用 需要修改为np.int
https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
'''
b = xywh2xyxy(b.reshape(-1, 4)).ravel().astype(np.int64)
# 以下为修改前
# b = xywh2xyxy(b.reshape(-1, 4)).ravel().astype(np.int)
b[[0, 2]] = np.clip(b[[0, 2]], 0, w) # clip boxes outside of image
b[[1, 3]] = np.clip(b[[1, 3]], 0, h)
assert cv2.imwrite(str(f), im[b[1]:b[3], b[0]:b[2]]), f'box failure in {f}'
def autosplit(path=DATASETS_DIR / 'coco128/images', weights=(0.9, 0.1, 0.0), annotated_only=False):
""" Autosplit a dataset into train/val/test splits and save path/autosplit_*.txt files
Usage: from utils.dataloaders import *; autosplit()
Arguments
path: Path to images directory
weights: Train, val, test weights (list, tuple)
annotated_only: Only use images with an annotated txt file
"""
path = Path(path) # images dir
files = sorted(x for x in path.rglob('*.*') if x.suffix[1:].lower() in IMG_FORMATS) # image files only
n = len(files) # number of files
random.seed(0) # for reproducibility
indices = random.choices([0, 1, 2], weights=weights, k=n) # assign each image to a split
txt = ['autosplit_train.txt', 'autosplit_val.txt', 'autosplit_test.txt'] # 3 txt files
[(path.parent / x).unlink(missing_ok=True) for x in txt] # remove existing
print(f'Autosplitting images from {path}' + ', using *.txt labeled images only' * annotated_only)
for i, img in tqdm(zip(indices, files), total=n):
if not annotated_only or Path(img2label_paths([str(img)])[0]).exists(): # check label
with open(path.parent / txt[i], 'a') as f:
f.write(f'./{img.relative_to(path.parent).as_posix()}' + '\n') # add image to txt file
def verify_image_label(args):
# Verify one image-label pair
im_file, lb_file, prefix = args
nm, nf, ne, nc, msg, segments = 0, 0, 0, 0, '', [] # number (missing, found, empty, corrupt), message, segments
try:
# verify images
im = Image.open(im_file)
im.verify() # PIL verify
shape = exif_size(im) # image size
assert (shape[0] > 9) & (shape[1] > 9), f'image size {shape} <10 pixels'
assert im.format.lower() in IMG_FORMATS, f'invalid image format {im.format}'
if im.format.lower() in ('jpg', 'jpeg'):
with open(im_file, 'rb') as f:
f.seek(-2, 2)
if f.read() != b'\xff\xd9': # corrupt JPEG
ImageOps.exif_transpose(Image.open(im_file)).save(im_file, 'JPEG', subsampling=0, quality=100)
msg = f'{prefix}WARNING: {im_file}: corrupt JPEG restored and saved'
# verify labels
if os.path.isfile(lb_file):
nf = 1 # label found
with open(lb_file) as f:
lb = [x.split() for x in f.read().strip().splitlines() if len(x)]
if any(len(x) > 6 for x in lb): # is segment
classes = np.array([x[0] for x in lb], dtype=np.float32)
segments = [np.array(x[1:], dtype=np.float32).reshape(-1, 2) for x in lb] # (cls, xy1...)
lb = np.concatenate((classes.reshape(-1, 1), segments2boxes(segments)), 1) # (cls, xywh)
lb = np.array(lb, dtype=np.float32)
nl = len(lb)
if nl:
assert lb.shape[1] == 5, f'labels require 5 columns, {lb.shape[1]} columns detected'
assert (lb >= 0).all(), f'negative label values {lb[lb < 0]}'
assert (lb[:, 1:] <= 1).all(), f'non-normalized or out of bounds coordinates {lb[:, 1:][lb[:, 1:] > 1]}'
_, i = np.unique(lb, axis=0, return_index=True)
if len(i) < nl: # duplicate row check
lb = lb[i] # remove duplicates
if segments:
segments = segments[i]
msg = f'{prefix}WARNING: {im_file}: {nl - len(i)} duplicate labels removed'
else:
ne = 1 # label empty
lb = np.zeros((0, 5), dtype=np.float32)
else:
nm = 1 # label missing
lb = np.zeros((0, 5), dtype=np.float32)
return im_file, lb, shape, segments, nm, nf, ne, nc, msg
except Exception as e:
nc = 1
msg = f'{prefix}WARNING: {im_file}: ignoring corrupt image/label: {e}'
return [None, None, None, None, nm, nf, ne, nc, msg]
class HUBDatasetStats():
""" Return dataset statistics dictionary with images and instances counts per split per class
To run in parent directory: export PYTHONPATH="$PWD/yolov5"
Usage1: from utils.dataloaders import *; HUBDatasetStats('coco128.yaml', autodownload=True)
Usage2: from utils.dataloaders import *; HUBDatasetStats('path/to/coco128_with_yaml.zip')
Arguments
path: Path to data.yaml or data.zip (with data.yaml inside data.zip)
autodownload: Attempt to download dataset if not found locally
"""
def __init__(self, path='coco128.yaml', autodownload=False):
# Initialize class
zipped, data_dir, yaml_path = self._unzip(Path(path))
try:
with open(check_yaml(yaml_path), errors='ignore') as f:
data = yaml.safe_load(f) # data dict
if zipped:
data['path'] = data_dir
except Exception as e:
raise Exception("error/HUB/dataset_stats/yaml_load") from e
check_dataset(data, autodownload) # download dataset if missing
self.hub_dir = Path(data['path'] + '-hub')
self.im_dir = self.hub_dir / 'images'
self.im_dir.mkdir(parents=True, exist_ok=True) # makes /images
self.stats = {'nc': data['nc'], 'names': data['names']} # statistics dictionary
self.data = data
@staticmethod
def _find_yaml(dir):
# Return data.yaml file
files = list(dir.glob('*.yaml')) or list(dir.rglob('*.yaml')) # try root level first and then recursive
assert files, f'No *.yaml file found in {dir}'
if len(files) > 1:
files = [f for f in files if f.stem == dir.stem] # prefer *.yaml files that match dir name
assert files, f'Multiple *.yaml files found in {dir}, only 1 *.yaml file allowed'
assert len(files) == 1, f'Multiple *.yaml files found: {files}, only 1 *.yaml file allowed in {dir}'
return files[0]
def _unzip(self, path):
# Unzip data.zip
if not str(path).endswith('.zip'): # path is data.yaml
return False, None, path
assert Path(path).is_file(), f'Error unzipping {path}, file not found'
ZipFile(path).extractall(path=path.parent) # unzip
dir = path.with_suffix('') # dataset directory == zip name
assert dir.is_dir(), f'Error unzipping {path}, {dir} not found. path/to/abc.zip MUST unzip to path/to/abc/'
return True, str(dir), self._find_yaml(dir) # zipped, data_dir, yaml_path
def _hub_ops(self, f, max_dim=1920):
# HUB ops for 1 image 'f': resize and save at reduced quality in /dataset-hub for web/app viewing
f_new = self.im_dir / Path(f).name # dataset-hub image filename
try: # use PIL
im = Image.open(f)
r = max_dim / max(im.height, im.width) # ratio
if r < 1.0: # image too large
im = im.resize((int(im.width * r), int(im.height * r)))
im.save(f_new, 'JPEG', quality=50, optimize=True) # save
except Exception as e: # use OpenCV
print(f'WARNING: HUB ops PIL failure {f}: {e}')
im = cv2.imread(f)
im_height, im_width = im.shape[:2]
r = max_dim / max(im_height, im_width) # ratio
if r < 1.0: # image too large
im = cv2.resize(im, (int(im_width * r), int(im_height * r)), interpolation=cv2.INTER_AREA)
cv2.imwrite(str(f_new), im)
def get_json(self, save=False, verbose=False):
# Return dataset JSON for Ultralytics HUB
def _round(labels):
# Update labels to integer class and 6 decimal place floats
return [[int(c), *(round(x, 4) for x in points)] for c, *points in labels]
for split in 'train', 'val', 'test':
if self.data.get(split) is None:
self.stats[split] = None # i.e. no test set
continue
dataset = LoadImagesAndLabels(self.data[split]) # load dataset
x = np.array([
np.bincount(label[:, 0].astype(int), minlength=self.data['nc'])
for label in tqdm(dataset.labels, total=dataset.n, desc='Statistics')]) # shape(128x80)
self.stats[split] = {
'instance_stats': {
'total': int(x.sum()),
'per_class': x.sum(0).tolist()},
'image_stats': {
'total': dataset.n,
'unlabelled': int(np.all(x == 0, 1).sum()),
'per_class': (x > 0).sum(0).tolist()},
'labels': [{
str(Path(k).name): _round(v.tolist())} for k, v in zip(dataset.im_files, dataset.labels)]}
# Save, print and return
if save:
stats_path = self.hub_dir / 'stats.json'
print(f'Saving {stats_path.resolve()}...')
with open(stats_path, 'w') as f:
json.dump(self.stats, f) # save stats.json
if verbose:
print(json.dumps(self.stats, indent=2, sort_keys=False))
return self.stats
def process_images(self):
# Compress images for Ultralytics HUB
for split in 'train', 'val', 'test':
if self.data.get(split) is None:
continue
dataset = LoadImagesAndLabels(self.data[split]) # load dataset
desc = f'{split} images'
for _ in tqdm(ThreadPool(NUM_THREADS).imap(self._hub_ops, dataset.im_files), total=dataset.n, desc=desc):
pass
print(f'Done. All images saved to {self.im_dir}')
return self.im_dir
# Classification dataloaders -------------------------------------------------------------------------------------------
class ClassificationDataset(torchvision.datasets.ImageFolder):
"""
YOLOv5 Classification Dataset.
Arguments
root: Dataset path
transform: torchvision transforms, used by default
album_transform: Albumentations transforms, used if installed
"""
def __init__(self, root, augment, imgsz, cache=False):
super().__init__(root=root)
self.torch_transforms = classify_transforms(imgsz)
self.album_transforms = classify_albumentations(augment, imgsz) if augment else None
self.cache_ram = cache is True or cache == 'ram'
self.cache_disk = cache == 'disk'
self.samples = [list(x) + [Path(x[0]).with_suffix('.npy'), None] for x in self.samples] # file, index, npy, im
def __getitem__(self, i):
f, j, fn, im = self.samples[i] # filename, index, filename.with_suffix('.npy'), image
if self.album_transforms:
if self.cache_ram and im is None:
im = self.samples[i][3] = cv2.imread(f)
elif self.cache_disk:
if not fn.exists(): # load npy
np.save(fn.as_posix(), cv2.imread(f))
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
sample = self.album_transforms(image=cv2.cvtColor(im, cv2.COLOR_BGR2RGB))["image"]
else:
sample = self.torch_transforms(self.loader(f))
return sample, j
def create_classification_dataloader(path,
imgsz=224,
batch_size=16,
augment=True,
cache=False,
rank=-1,
workers=8,
shuffle=True):
# Returns Dataloader object to be used with YOLOv5 Classifier
with torch_distributed_zero_first(rank): # init dataset *.cache only once if DDP
dataset = ClassificationDataset(root=path, imgsz=imgsz, augment=augment, cache=cache)
batch_size = min(batch_size, len(dataset))
nd = torch.cuda.device_count()
nw = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, workers])
sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)
generator = torch.Generator()
generator.manual_seed(0)
return InfiniteDataLoader(dataset,
batch_size=batch_size,
shuffle=shuffle and sampler is None,
num_workers=nw,
sampler=sampler,
pin_memory=True,
worker_init_fn=seed_worker,
generator=generator) # or DataLoader(persistent_workers=True)
| 52,334 | Python | .py | 1,024 | 38.666016 | 120 | 0.541404 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,519 | torch_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/torch_utils.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
PyTorch utils
"""
import math
import os
import platform
import subprocess
import time
import warnings
from contextlib import contextmanager
from copy import deepcopy
from pathlib import Path
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parallel import DistributedDataParallel as DDP
from utils.general import LOGGER, check_version, colorstr, file_date, git_describe
LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1)) # https://pytorch.org/docs/stable/elastic/run.html
RANK = int(os.getenv('RANK', -1))
WORLD_SIZE = int(os.getenv('WORLD_SIZE', 1))
try:
import thop # for FLOPs computation
except ImportError:
thop = None
# Suppress PyTorch warnings
warnings.filterwarnings('ignore', message='User provided device_type of \'cuda\', but CUDA is not available. Disabling')
def smart_inference_mode(torch_1_9=check_version(torch.__version__, '1.9.0')):
# Applies torch.inference_mode() decorator if torch>=1.9.0 else torch.no_grad() decorator
def decorate(fn):
return (torch.inference_mode if torch_1_9 else torch.no_grad)()(fn)
return decorate
def smartCrossEntropyLoss(label_smoothing=0.0):
# Returns nn.CrossEntropyLoss with label smoothing enabled for torch>=1.10.0
if check_version(torch.__version__, '1.10.0'):
return nn.CrossEntropyLoss(label_smoothing=label_smoothing) # loss function
else:
if label_smoothing > 0:
LOGGER.warning(f'WARNING: label smoothing {label_smoothing} requires torch>=1.10.0')
return nn.CrossEntropyLoss() # loss function
def smart_DDP(model):
# Model DDP creation with checks
assert not check_version(torch.__version__, '1.12.0', pinned=True), \
'torch==1.12.0 torchvision==0.13.0 DDP training is not supported due to a known issue. ' \
'Please upgrade or downgrade torch to use DDP. See https://github.com/ultralytics/yolov5/issues/8395'
if check_version(torch.__version__, '1.11.0'):
return DDP(model, device_ids=[LOCAL_RANK], output_device=LOCAL_RANK, static_graph=True)
else:
return DDP(model, device_ids=[LOCAL_RANK], output_device=LOCAL_RANK)
def reshape_classifier_output(model, n=1000):
# Update a TorchVision classification model to class count 'n' if required
from models.common import Classify
name, m = list((model.model if hasattr(model, 'model') else model).named_children())[-1] # last module
if isinstance(m, Classify): # YOLOv5 Classify() head
if m.linear.out_features != n:
m.linear = nn.Linear(m.linear.in_features, n)
elif isinstance(m, nn.Linear): # ResNet, EfficientNet
if m.out_features != n:
setattr(model, name, nn.Linear(m.in_features, n))
elif isinstance(m, nn.Sequential):
types = [type(x) for x in m]
if nn.Linear in types:
i = types.index(nn.Linear) # nn.Linear index
if m[i].out_features != n:
m[i] = nn.Linear(m[i].in_features, n)
elif nn.Conv2d in types:
i = types.index(nn.Conv2d) # nn.Conv2d index
if m[i].out_channels != n:
m[i] = nn.Conv2d(m[i].in_channels, n, m[i].kernel_size, m[i].stride, bias=m[i].bias)
@contextmanager
def torch_distributed_zero_first(local_rank: int):
# Decorator to make all processes in distributed training wait for each local_master to do something
if local_rank not in [-1, 0]:
dist.barrier(device_ids=[local_rank])
yield
if local_rank == 0:
dist.barrier(device_ids=[0])
def device_count():
# Returns number of CUDA devices available. Safe version of torch.cuda.device_count(). Supports Linux and Windows
assert platform.system() in ('Linux', 'Windows'), 'device_count() only supported on Linux or Windows'
try:
cmd = 'nvidia-smi -L | wc -l' if platform.system() == 'Linux' else 'nvidia-smi -L | find /c /v ""' # Windows
return int(subprocess.run(cmd, shell=True, capture_output=True, check=True).stdout.decode().split()[-1])
except Exception:
return 0
def select_device(device='', batch_size=0, newline=True):
# device = None or 'cpu' or 0 or '0' or '0,1,2,3'
s = f'YOLOv5 🚀 {git_describe() or file_date()} Python-{platform.python_version()} torch-{torch.__version__} '
device = str(device).strip().lower().replace('cuda:', '').replace('none', '') # to string, 'cuda:0' to '0'
cpu = device == 'cpu'
mps = device == 'mps' # Apple Metal Performance Shaders (MPS)
if cpu or mps:
os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False
elif device: # non-cpu device requested
os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable - must be before assert is_available()
assert torch.cuda.is_available() and torch.cuda.device_count() >= len(device.replace(',', '')), \
f"Invalid CUDA '--device {device}' requested, use '--device cpu' or pass valid CUDA device(s)"
if not (cpu or mps) and torch.cuda.is_available(): # prefer GPU if available
devices = device.split(',') if device else '0' # range(torch.cuda.device_count()) # i.e. 0,1,6,7
n = len(devices) # device count
if n > 1 and batch_size > 0: # check batch_size is divisible by device_count
assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
space = ' ' * (len(s) + 1)
for i, d in enumerate(devices):
p = torch.cuda.get_device_properties(i)
s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / (1 << 20):.0f}MiB)\n" # bytes to MB
arg = 'cuda:0'
elif mps and getattr(torch, 'has_mps', False) and torch.backends.mps.is_available(): # prefer MPS if available
s += 'MPS\n'
arg = 'mps'
else: # revert to CPU
s += 'CPU\n'
arg = 'cpu'
if not newline:
s = s.rstrip()
LOGGER.info(s)
return torch.device(arg)
def time_sync():
# PyTorch-accurate time
if torch.cuda.is_available():
torch.cuda.synchronize()
return time.time()
def profile(input, ops, n=10, device=None):
""" YOLOv5 speed/memory/FLOPs profiler
Usage:
input = torch.randn(16, 3, 640, 640)
m1 = lambda x: x * torch.sigmoid(x)
m2 = nn.SiLU()
profile(input, [m1, m2], n=100) # profile over 100 iterations
"""
results = []
if not isinstance(device, torch.device):
device = select_device(device)
print(f"{'Params':>12s}{'GFLOPs':>12s}{'GPU_mem (GB)':>14s}{'forward (ms)':>14s}{'backward (ms)':>14s}"
f"{'input':>24s}{'output':>24s}")
for x in input if isinstance(input, list) else [input]:
x = x.to(device)
x.requires_grad = True
for m in ops if isinstance(ops, list) else [ops]:
m = m.to(device) if hasattr(m, 'to') else m # device
m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m
tf, tb, t = 0, 0, [0, 0, 0] # dt forward, backward
try:
flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # GFLOPs
except Exception:
flops = 0
try:
for _ in range(n):
t[0] = time_sync()
y = m(x)
t[1] = time_sync()
try:
_ = (sum(yi.sum() for yi in y) if isinstance(y, list) else y).sum().backward()
t[2] = time_sync()
except Exception: # no backward method
# print(e) # for debug
t[2] = float('nan')
tf += (t[1] - t[0]) * 1000 / n # ms per op forward
tb += (t[2] - t[1]) * 1000 / n # ms per op backward
mem = torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0 # (GB)
s_in, s_out = (tuple(x.shape) if isinstance(x, torch.Tensor) else 'list' for x in (x, y)) # shapes
p = sum(x.numel() for x in m.parameters()) if isinstance(m, nn.Module) else 0 # parameters
print(f'{p:12}{flops:12.4g}{mem:>14.3f}{tf:14.4g}{tb:14.4g}{str(s_in):>24s}{str(s_out):>24s}')
results.append([p, flops, mem, tf, tb, s_in, s_out])
except Exception as e:
print(e)
results.append(None)
torch.cuda.empty_cache()
return results
def is_parallel(model):
# Returns True if model is of type DP or DDP
return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
def de_parallel(model):
# De-parallelize a model: returns single-GPU model if model is of type DP or DDP
return model.module if is_parallel(model) else model
def initialize_weights(model):
for m in model.modules():
t = type(m)
if t is nn.Conv2d:
pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
elif t is nn.BatchNorm2d:
m.eps = 1e-3
m.momentum = 0.03
elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]:
m.inplace = True
def find_modules(model, mclass=nn.Conv2d):
# Finds layer indices matching module class 'mclass'
return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
def sparsity(model):
# Return global model sparsity
a, b = 0, 0
for p in model.parameters():
a += p.numel()
b += (p == 0).sum()
return b / a
def prune(model, amount=0.3):
# Prune model to requested global sparsity
import torch.nn.utils.prune as prune
for name, m in model.named_modules():
if isinstance(m, nn.Conv2d):
prune.l1_unstructured(m, name='weight', amount=amount) # prune
prune.remove(m, 'weight') # make permanent
LOGGER.info(f'Model pruned to {sparsity(model):.3g} global sparsity')
def fuse_conv_and_bn(conv, bn):
# Fuse Conv2d() and BatchNorm2d() layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
fusedconv = nn.Conv2d(conv.in_channels,
conv.out_channels,
kernel_size=conv.kernel_size,
stride=conv.stride,
padding=conv.padding,
groups=conv.groups,
bias=True).requires_grad_(False).to(conv.weight.device)
# Prepare filters
w_conv = conv.weight.clone().view(conv.out_channels, -1)
w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
# Prepare spatial bias
b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
return fusedconv
def model_info(model, verbose=False, imgsz=640):
# Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
n_p = sum(x.numel() for x in model.parameters()) # number parameters
n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients
if verbose:
print(f"{'layer':>5} {'name':>40} {'gradient':>9} {'parameters':>12} {'shape':>20} {'mu':>10} {'sigma':>10}")
for i, (name, p) in enumerate(model.named_parameters()):
name = name.replace('module_list.', '')
print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
(i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
try: # FLOPs
p = next(model.parameters())
stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32 # max stride
im = torch.zeros((1, p.shape[1], stride, stride), device=p.device) # input image in BCHW format
flops = thop.profile(deepcopy(model), inputs=(im,), verbose=False)[0] / 1E9 * 2 # stride GFLOPs
imgsz = imgsz if isinstance(imgsz, list) else [imgsz, imgsz] # expand if int/float
fs = f', {flops * imgsz[0] / stride * imgsz[1] / stride:.1f} GFLOPs' # 640x640 GFLOPs
except Exception:
fs = ''
name = Path(model.yaml_file).stem.replace('yolov5', 'YOLOv5') if hasattr(model, 'yaml_file') else 'Model'
LOGGER.info(f"{name} summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
def scale_img(img, ratio=1.0, same_shape=False, gs=32): # img(16,3,256,416)
# Scales img(bs,3,y,x) by ratio constrained to gs-multiple
if ratio == 1.0:
return img
h, w = img.shape[2:]
s = (int(h * ratio), int(w * ratio)) # new size
img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize
if not same_shape: # pad/crop img
h, w = (math.ceil(x * ratio / gs) * gs for x in (h, w))
return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean
def copy_attr(a, b, include=(), exclude=()):
# Copy attributes from b to a, options to only include [...] and to exclude [...]
for k, v in b.__dict__.items():
if (len(include) and k not in include) or k.startswith('_') or k in exclude:
continue
else:
setattr(a, k, v)
def smart_optimizer(model, name='Adam', lr=0.001, momentum=0.9, decay=1e-5):
# YOLOv5 3-param group optimizer: 0) weights with decay, 1) weights no decay, 2) biases no decay
g = [], [], [] # optimizer parameter groups
bn = tuple(v for k, v in nn.__dict__.items() if 'Norm' in k) # normalization layers, i.e. BatchNorm2d()
for v in model.modules():
if hasattr(v, 'bias') and isinstance(v.bias, nn.Parameter): # bias (no decay)
g[2].append(v.bias)
if isinstance(v, bn): # weight (no decay)
g[1].append(v.weight)
elif hasattr(v, 'weight') and isinstance(v.weight, nn.Parameter): # weight (with decay)
g[0].append(v.weight)
if name == 'Adam':
optimizer = torch.optim.Adam(g[2], lr=lr, betas=(momentum, 0.999)) # adjust beta1 to momentum
elif name == 'AdamW':
optimizer = torch.optim.AdamW(g[2], lr=lr, betas=(momentum, 0.999), weight_decay=0.0)
elif name == 'RMSProp':
optimizer = torch.optim.RMSprop(g[2], lr=lr, momentum=momentum)
elif name == 'SGD':
optimizer = torch.optim.SGD(g[2], lr=lr, momentum=momentum, nesterov=True)
else:
raise NotImplementedError(f'Optimizer {name} not implemented.')
optimizer.add_param_group({'params': g[0], 'weight_decay': decay}) # add g0 with weight_decay
optimizer.add_param_group({'params': g[1], 'weight_decay': 0.0}) # add g1 (BatchNorm2d weights)
LOGGER.info(f"{colorstr('optimizer:')} {type(optimizer).__name__}(lr={lr}) with parameter groups "
f"{len(g[1])} weight(decay=0.0), {len(g[0])} weight(decay={decay}), {len(g[2])} bias")
return optimizer
def smart_hub_load(repo='ultralytics/yolov5', model='yolov5s', **kwargs):
# YOLOv5 torch.hub.load() wrapper with smart error/issue handling
if check_version(torch.__version__, '1.9.1'):
kwargs['skip_validation'] = True # validation causes GitHub API rate limit errors
if check_version(torch.__version__, '1.12.0'):
kwargs['trust_repo'] = True # argument required starting in torch 0.12
try:
return torch.hub.load(repo, model, **kwargs)
except Exception:
return torch.hub.load(repo, model, force_reload=True, **kwargs)
def smart_resume(ckpt, optimizer, ema=None, weights='yolov5s.pt', epochs=300, resume=True):
# Resume training from a partially trained checkpoint
best_fitness = 0.0
start_epoch = ckpt['epoch'] + 1
if ckpt['optimizer'] is not None:
optimizer.load_state_dict(ckpt['optimizer']) # optimizer
best_fitness = ckpt['best_fitness']
if ema and ckpt.get('ema'):
ema.ema.load_state_dict(ckpt['ema'].float().state_dict()) # EMA
ema.updates = ckpt['updates']
if resume:
assert start_epoch > 0, f'{weights} training to {epochs} epochs is finished, nothing to resume.\n' \
f"Start a new training without --resume, i.e. 'python train.py --weights {weights}'"
LOGGER.info(f'Resuming training from {weights} from epoch {start_epoch} to {epochs} total epochs')
if epochs < start_epoch:
LOGGER.info(f"{weights} has been trained for {ckpt['epoch']} epochs. Fine-tuning for {epochs} more epochs.")
epochs += ckpt['epoch'] # finetune additional epochs
return best_fitness, start_epoch, epochs
class EarlyStopping:
# YOLOv5 simple early stopper
def __init__(self, patience=30):
self.best_fitness = 0.0 # i.e. mAP
self.best_epoch = 0
self.patience = patience or float('inf') # epochs to wait after fitness stops improving to stop
self.possible_stop = False # possible stop may occur next epoch
def __call__(self, epoch, fitness):
if fitness >= self.best_fitness: # >= 0 to allow for early zero-fitness stage of training
self.best_epoch = epoch
self.best_fitness = fitness
delta = epoch - self.best_epoch # epochs without improvement
self.possible_stop = delta >= (self.patience - 1) # possible stop may occur next epoch
stop = delta >= self.patience # stop training if patience exceeded
if stop:
LOGGER.info(f'Stopping training early as no improvement observed in last {self.patience} epochs. '
f'Best results observed at epoch {self.best_epoch}, best model saved as best.pt.\n'
f'To update EarlyStopping(patience={self.patience}) pass a new patience value, '
f'i.e. `python train.py --patience 300` or use `--patience 0` to disable EarlyStopping.')
return stop
class ModelEMA:
""" Updated Exponential Moving Average (EMA) from https://github.com/rwightman/pytorch-image-models
Keeps a moving average of everything in the model state_dict (parameters and buffers)
For EMA details see https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
"""
def __init__(self, model, decay=0.9999, tau=2000, updates=0):
# Create EMA
self.ema = deepcopy(de_parallel(model)).eval() # FP32 EMA
# if next(model.parameters()).device.type != 'cpu':
# self.ema.half() # FP16 EMA
self.updates = updates # number of EMA updates
self.decay = lambda x: decay * (1 - math.exp(-x / tau)) # decay exponential ramp (to help early epochs)
for p in self.ema.parameters():
p.requires_grad_(False)
@smart_inference_mode()
def update(self, model):
# Update EMA parameters
self.updates += 1
d = self.decay(self.updates)
msd = de_parallel(model).state_dict() # model state_dict
for k, v in self.ema.state_dict().items():
if v.dtype.is_floating_point:
v *= d
v += (1 - d) * msd[k].detach()
def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
# Update EMA attributes
copy_attr(self.ema, model, include, exclude)
| 19,568 | Python | .py | 361 | 45.894737 | 120 | 0.622492 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,520 | autoanchor.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/autoanchor.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
AutoAnchor utils
"""
import random
import numpy as np
import torch
import yaml
from tqdm import tqdm
from utils.general import LOGGER, colorstr
PREFIX = colorstr('AutoAnchor: ')
def check_anchor_order(m):
# Check anchor order against stride order for YOLOv5 Detect() module m, and correct if necessary
a = m.anchors.prod(-1).mean(-1).view(-1) # mean anchor area per output layer
da = a[-1] - a[0] # delta a
ds = m.stride[-1] - m.stride[0] # delta s
if da and (da.sign() != ds.sign()): # same order
LOGGER.info(f'{PREFIX}Reversing anchor order')
m.anchors[:] = m.anchors.flip(0)
def check_anchors(dataset, model, thr=4.0, imgsz=640):
# Check anchor fit to data, recompute if necessary
m = model.module.model[-1] if hasattr(model, 'module') else model.model[-1] # Detect()
shapes = imgsz * dataset.shapes / dataset.shapes.max(1, keepdims=True)
scale = np.random.uniform(0.9, 1.1, size=(shapes.shape[0], 1)) # augment scale
wh = torch.tensor(np.concatenate([l[:, 3:5] * s for s, l in zip(shapes * scale, dataset.labels)])).float() # wh
def metric(k): # compute metric
r = wh[:, None] / k[None]
x = torch.min(r, 1 / r).min(2)[0] # ratio metric
best = x.max(1)[0] # best_x
aat = (x > 1 / thr).float().sum(1).mean() # anchors above threshold
bpr = (best > 1 / thr).float().mean() # best possible recall
return bpr, aat
stride = m.stride.to(m.anchors.device).view(-1, 1, 1) # model strides
anchors = m.anchors.clone() * stride # current anchors
bpr, aat = metric(anchors.cpu().view(-1, 2))
s = f'\n{PREFIX}{aat:.2f} anchors/target, {bpr:.3f} Best Possible Recall (BPR). '
if bpr > 0.98: # threshold to recompute
LOGGER.info(f'{s}Current anchors are a good fit to dataset ✅')
else:
LOGGER.info(f'{s}Anchors are a poor fit to dataset ⚠�, attempting to improve...')
na = m.anchors.numel() // 2 # number of anchors
try:
anchors = kmean_anchors(dataset, n=na, img_size=imgsz, thr=thr, gen=1000, verbose=False)
except Exception as e:
LOGGER.info(f'{PREFIX}ERROR: {e}')
new_bpr = metric(anchors)[0]
if new_bpr > bpr: # replace anchors
anchors = torch.tensor(anchors, device=m.anchors.device).type_as(m.anchors)
m.anchors[:] = anchors.clone().view_as(m.anchors)
check_anchor_order(m) # must be in pixel-space (not grid-space)
m.anchors /= stride
s = f'{PREFIX}Done ✅ (optional: update model *.yaml to use these anchors in the future)'
else:
s = f'{PREFIX}Done ⚠� (original anchors better than new anchors, proceeding with original anchors)'
LOGGER.info(s)
def kmean_anchors(dataset='./data/coco128.yaml', n=9, img_size=640, thr=4.0, gen=1000, verbose=True):
""" Creates kmeans-evolved anchors from training dataset
Arguments:
dataset: path to data.yaml, or a loaded dataset
n: number of anchors
img_size: image size used for training
thr: anchor-label wh ratio threshold hyperparameter hyp['anchor_t'] used for training, default=4.0
gen: generations to evolve anchors using genetic algorithm
verbose: print all results
Return:
k: kmeans evolved anchors
Usage:
from utils.autoanchor import *; _ = kmean_anchors()
"""
from scipy.cluster.vq import kmeans
npr = np.random
thr = 1 / thr
def metric(k, wh): # compute metrics
r = wh[:, None] / k[None]
x = torch.min(r, 1 / r).min(2)[0] # ratio metric
# x = wh_iou(wh, torch.tensor(k)) # iou metric
return x, x.max(1)[0] # x, best_x
def anchor_fitness(k): # mutation fitness
_, best = metric(torch.tensor(k, dtype=torch.float32), wh)
return (best * (best > thr).float()).mean() # fitness
def print_results(k, verbose=True):
k = k[np.argsort(k.prod(1))] # sort small to large
x, best = metric(k, wh0)
bpr, aat = (best > thr).float().mean(), (x > thr).float().mean() * n # best possible recall, anch > thr
s = f'{PREFIX}thr={thr:.2f}: {bpr:.4f} best possible recall, {aat:.2f} anchors past thr\n' \
f'{PREFIX}n={n}, img_size={img_size}, metric_all={x.mean():.3f}/{best.mean():.3f}-mean/best, ' \
f'past_thr={x[x > thr].mean():.3f}-mean: '
for x in k:
s += '%i,%i, ' % (round(x[0]), round(x[1]))
if verbose:
LOGGER.info(s[:-2])
return k
if isinstance(dataset, str): # *.yaml file
with open(dataset, errors='ignore') as f:
data_dict = yaml.safe_load(f) # model dict
from utils.dataloaders import LoadImagesAndLabels
dataset = LoadImagesAndLabels(data_dict['train'], augment=True, rect=True)
# Get label wh
shapes = img_size * dataset.shapes / dataset.shapes.max(1, keepdims=True)
wh0 = np.concatenate([l[:, 3:5] * s for s, l in zip(shapes, dataset.labels)]) # wh
# Filter
i = (wh0 < 3.0).any(1).sum()
if i:
LOGGER.info(f'{PREFIX}WARNING: Extremely small objects found: {i} of {len(wh0)} labels are < 3 pixels in size')
wh = wh0[(wh0 >= 2.0).any(1)] # filter > 2 pixels
# wh = wh * (npr.rand(wh.shape[0], 1) * 0.9 + 0.1) # multiply by random scale 0-1
# Kmeans init
try:
LOGGER.info(f'{PREFIX}Running kmeans for {n} anchors on {len(wh)} points...')
assert n <= len(wh) # apply overdetermined constraint
s = wh.std(0) # sigmas for whitening
k = kmeans(wh / s, n, iter=30)[0] * s # points
assert n == len(k) # kmeans may return fewer points than requested if wh is insufficient or too similar
except Exception:
LOGGER.warning(f'{PREFIX}WARNING: switching strategies from kmeans to random init')
k = np.sort(npr.rand(n * 2)).reshape(n, 2) * img_size # random init
wh, wh0 = (torch.tensor(x, dtype=torch.float32) for x in (wh, wh0))
k = print_results(k, verbose=False)
# Plot
# k, d = [None] * 20, [None] * 20
# for i in tqdm(range(1, 21)):
# k[i-1], d[i-1] = kmeans(wh / s, i) # points, mean distance
# fig, ax = plt.subplots(1, 2, figsize=(14, 7), tight_layout=True)
# ax = ax.ravel()
# ax[0].plot(np.arange(1, 21), np.array(d) ** 2, marker='.')
# fig, ax = plt.subplots(1, 2, figsize=(14, 7)) # plot wh
# ax[0].hist(wh[wh[:, 0]<100, 0],400)
# ax[1].hist(wh[wh[:, 1]<100, 1],400)
# fig.savefig('wh.png', dpi=200)
# Evolve
f, sh, mp, s = anchor_fitness(k), k.shape, 0.9, 0.1 # fitness, generations, mutation prob, sigma
pbar = tqdm(range(gen), bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}') # progress bar
for _ in pbar:
v = np.ones(sh)
while (v == 1).all(): # mutate until a change occurs (prevent duplicates)
v = ((npr.random(sh) < mp) * random.random() * npr.randn(*sh) * s + 1).clip(0.3, 3.0)
kg = (k.copy() * v).clip(min=2.0)
fg = anchor_fitness(kg)
if fg > f:
f, k = fg, kg.copy()
pbar.desc = f'{PREFIX}Evolving anchors with Genetic Algorithm: fitness = {f:.4f}'
if verbose:
print_results(k, verbose)
return print_results(k)
| 7,411 | Python | .py | 144 | 43.840278 | 119 | 0.59826 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,521 | augmentations.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/augmentations.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Image augmentation functions
"""
import math
import random
import cv2
import numpy as np
import torchvision.transforms as T
import torchvision.transforms.functional as TF
from utils.general import LOGGER, check_version, colorstr, resample_segments, segment2box
from utils.metrics import bbox_ioa
IMAGENET_MEAN = 0.485, 0.456, 0.406 # RGB mean
IMAGENET_STD = 0.229, 0.224, 0.225 # RGB standard deviation
class Albumentations:
# YOLOv5 Albumentations class (optional, only used if package is installed)
def __init__(self):
self.transform = None
prefix = colorstr('albumentations: ')
try:
import albumentations as A
check_version(A.__version__, '1.0.3', hard=True) # version requirement
T = [
A.Blur(p=0.01),
A.MedianBlur(p=0.01),
A.ToGray(p=0.01),
A.CLAHE(p=0.01),
A.RandomBrightnessContrast(p=0.0),
A.RandomGamma(p=0.0),
A.ImageCompression(quality_lower=75, p=0.0)] # transforms
self.transform = A.Compose(T, bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))
LOGGER.info(prefix + ', '.join(f'{x}'.replace('always_apply=False, ', '') for x in T if x.p))
except ImportError: # package not installed, skip
pass
except Exception as e:
LOGGER.info(f'{prefix}{e}')
def __call__(self, im, labels, p=1.0):
if self.transform and random.random() < p:
new = self.transform(image=im, bboxes=labels[:, 1:], class_labels=labels[:, 0]) # transformed
im, labels = new['image'], np.array([[c, *b] for c, b in zip(new['class_labels'], new['bboxes'])])
return im, labels
def normalize(x, mean=IMAGENET_MEAN, std=IMAGENET_STD, inplace=False):
# Denormalize RGB images x per ImageNet stats in BCHW format, i.e. = (x - mean) / std
return TF.normalize(x, mean, std, inplace=inplace)
def denormalize(x, mean=IMAGENET_MEAN, std=IMAGENET_STD):
# Denormalize RGB images x per ImageNet stats in BCHW format, i.e. = x * std + mean
for i in range(3):
x[:, i] = x[:, i] * std[i] + mean[i]
return x
def augment_hsv(im, hgain=0.5, sgain=0.5, vgain=0.5):
# HSV color-space augmentation
if hgain or sgain or vgain:
r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains
hue, sat, val = cv2.split(cv2.cvtColor(im, cv2.COLOR_BGR2HSV))
dtype = im.dtype # uint8
x = np.arange(0, 256, dtype=r.dtype)
lut_hue = ((x * r[0]) % 180).astype(dtype)
lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
im_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val)))
cv2.cvtColor(im_hsv, cv2.COLOR_HSV2BGR, dst=im) # no return needed
def hist_equalize(im, clahe=True, bgr=False):
# Equalize histogram on BGR image 'im' with im.shape(n,m,3) and range 0-255
yuv = cv2.cvtColor(im, cv2.COLOR_BGR2YUV if bgr else cv2.COLOR_RGB2YUV)
if clahe:
c = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
yuv[:, :, 0] = c.apply(yuv[:, :, 0])
else:
yuv[:, :, 0] = cv2.equalizeHist(yuv[:, :, 0]) # equalize Y channel histogram
return cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR if bgr else cv2.COLOR_YUV2RGB) # convert YUV image to RGB
def replicate(im, labels):
# Replicate labels
h, w = im.shape[:2]
boxes = labels[:, 1:].astype(int)
x1, y1, x2, y2 = boxes.T
s = ((x2 - x1) + (y2 - y1)) / 2 # side length (pixels)
for i in s.argsort()[:round(s.size * 0.5)]: # smallest indices
x1b, y1b, x2b, y2b = boxes[i]
bh, bw = y2b - y1b, x2b - x1b
yc, xc = int(random.uniform(0, h - bh)), int(random.uniform(0, w - bw)) # offset x, y
x1a, y1a, x2a, y2a = [xc, yc, xc + bw, yc + bh]
im[y1a:y2a, x1a:x2a] = im[y1b:y2b, x1b:x2b] # im4[ymin:ymax, xmin:xmax]
labels = np.append(labels, [[labels[i, 0], x1a, y1a, x2a, y2a]], axis=0)
return im, labels
def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32):
# Resize and pad image while meeting stride-multiple constraints
shape = im.shape[:2] # current shape [height, width]
if isinstance(new_shape, int):
new_shape = (new_shape, new_shape)
# Scale ratio (new / old)
r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
if not scaleup: # only scale down, do not scale up (for better val mAP)
r = min(r, 1.0)
# Compute padding
ratio = r, r # width, height ratios
new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding
if auto: # minimum rectangle
dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding
elif scaleFill: # stretch
dw, dh = 0.0, 0.0
new_unpad = (new_shape[1], new_shape[0])
ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios
dw /= 2 # divide padding into 2 sides
dh /= 2
if shape[::-1] != new_unpad: # resize
im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border
return im, ratio, (dw, dh)
def random_perspective(im,
targets=(),
segments=(),
degrees=10,
translate=.1,
scale=.1,
shear=10,
perspective=0.0,
border=(0, 0)):
# torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(0.1, 0.1), scale=(0.9, 1.1), shear=(-10, 10))
# targets = [cls, xyxy]
height = im.shape[0] + border[0] * 2 # shape(h,w,c)
width = im.shape[1] + border[1] * 2
# Center
C = np.eye(3)
C[0, 2] = -im.shape[1] / 2 # x translation (pixels)
C[1, 2] = -im.shape[0] / 2 # y translation (pixels)
# Perspective
P = np.eye(3)
P[2, 0] = random.uniform(-perspective, perspective) # x perspective (about y)
P[2, 1] = random.uniform(-perspective, perspective) # y perspective (about x)
# Rotation and Scale
R = np.eye(3)
a = random.uniform(-degrees, degrees)
# a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations
s = random.uniform(1 - scale, 1 + scale)
# s = 2 ** random.uniform(-scale, scale)
R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)
# Shear
S = np.eye(3)
S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # x shear (deg)
S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # y shear (deg)
# Translation
T = np.eye(3)
T[0, 2] = random.uniform(0.5 - translate, 0.5 + translate) * width # x translation (pixels)
T[1, 2] = random.uniform(0.5 - translate, 0.5 + translate) * height # y translation (pixels)
# Combined rotation matrix
M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT
if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed
if perspective:
im = cv2.warpPerspective(im, M, dsize=(width, height), borderValue=(114, 114, 114))
else: # affine
im = cv2.warpAffine(im, M[:2], dsize=(width, height), borderValue=(114, 114, 114))
# Visualize
# import matplotlib.pyplot as plt
# ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel()
# ax[0].imshow(im[:, :, ::-1]) # base
# ax[1].imshow(im2[:, :, ::-1]) # warped
# Transform label coordinates
n = len(targets)
if n:
use_segments = any(x.any() for x in segments)
new = np.zeros((n, 4))
if use_segments: # warp segments
segments = resample_segments(segments) # upsample
for i, segment in enumerate(segments):
xy = np.ones((len(segment), 3))
xy[:, :2] = segment
xy = xy @ M.T # transform
xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] # perspective rescale or affine
# clip
new[i] = segment2box(xy, width, height)
else: # warp boxes
xy = np.ones((n * 4, 3))
xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape(n * 4, 2) # x1y1, x2y2, x1y2, x2y1
xy = xy @ M.T # transform
xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]).reshape(n, 8) # perspective rescale or affine
# create new boxes
x = xy[:, [0, 2, 4, 6]]
y = xy[:, [1, 3, 5, 7]]
new = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T
# clip
new[:, [0, 2]] = new[:, [0, 2]].clip(0, width)
new[:, [1, 3]] = new[:, [1, 3]].clip(0, height)
# filter candidates
i = box_candidates(box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10)
targets = targets[i]
targets[:, 1:5] = new[i]
return im, targets
def copy_paste(im, labels, segments, p=0.5):
# Implement Copy-Paste augmentation https://arxiv.org/abs/2012.07177, labels as nx5 np.array(cls, xyxy)
n = len(segments)
if p and n:
h, w, c = im.shape # height, width, channels
im_new = np.zeros(im.shape, np.uint8)
for j in random.sample(range(n), k=round(p * n)):
l, s = labels[j], segments[j]
box = w - l[3], l[2], w - l[1], l[4]
ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area
if (ioa < 0.30).all(): # allow 30% obscuration of existing labels
labels = np.concatenate((labels, [[l[0], *box]]), 0)
segments.append(np.concatenate((w - s[:, 0:1], s[:, 1:2]), 1))
cv2.drawContours(im_new, [segments[j].astype(np.int32)], -1, (255, 255, 255), cv2.FILLED)
result = cv2.bitwise_and(src1=im, src2=im_new)
result = cv2.flip(result, 1) # augment segments (flip left-right)
i = result > 0 # pixels to replace
# i[:, :] = result.max(2).reshape(h, w, 1) # act over ch
im[i] = result[i] # cv2.imwrite('debug.jpg', im) # debug
return im, labels, segments
def cutout(im, labels, p=0.5):
# Applies image cutout augmentation https://arxiv.org/abs/1708.04552
if random.random() < p:
h, w = im.shape[:2]
scales = [0.5] * 1 + [0.25] * 2 + [0.125] * 4 + [0.0625] * 8 + [0.03125] * 16 # image size fraction
for s in scales:
mask_h = random.randint(1, int(h * s)) # create random masks
mask_w = random.randint(1, int(w * s))
# box
xmin = max(0, random.randint(0, w) - mask_w // 2)
ymin = max(0, random.randint(0, h) - mask_h // 2)
xmax = min(w, xmin + mask_w)
ymax = min(h, ymin + mask_h)
# apply random color mask
im[ymin:ymax, xmin:xmax] = [random.randint(64, 191) for _ in range(3)]
# return unobscured labels
if len(labels) and s > 0.03:
box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32)
ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area
labels = labels[ioa < 0.60] # remove >60% obscured labels
return labels
def mixup(im, labels, im2, labels2):
# Applies MixUp augmentation https://arxiv.org/pdf/1710.09412.pdf
r = np.random.beta(32.0, 32.0) # mixup ratio, alpha=beta=32.0
im = (im * r + im2 * (1 - r)).astype(np.uint8)
labels = np.concatenate((labels, labels2), 0)
return im, labels
def box_candidates(box1, box2, wh_thr=2, ar_thr=100, area_thr=0.1, eps=1e-16): # box1(4,n), box2(4,n)
# Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio
w1, h1 = box1[2] - box1[0], box1[3] - box1[1]
w2, h2 = box2[2] - box2[0], box2[3] - box2[1]
ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio
return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) # candidates
def classify_albumentations(augment=True,
size=224,
scale=(0.08, 1.0),
hflip=0.5,
vflip=0.0,
jitter=0.4,
mean=IMAGENET_MEAN,
std=IMAGENET_STD,
auto_aug=False):
# YOLOv5 classification Albumentations (optional, only used if package is installed)
prefix = colorstr('albumentations: ')
try:
import albumentations as A
from albumentations.pytorch import ToTensorV2
check_version(A.__version__, '1.0.3', hard=True) # version requirement
if augment: # Resize and crop
T = [A.RandomResizedCrop(height=size, width=size, scale=scale)]
if auto_aug:
# TODO: implement AugMix, AutoAug & RandAug in albumentation
LOGGER.info(f'{prefix}auto augmentations are currently not supported')
else:
if hflip > 0:
T += [A.HorizontalFlip(p=hflip)]
if vflip > 0:
T += [A.VerticalFlip(p=vflip)]
if jitter > 0:
color_jitter = (float(jitter),) * 3 # repeat value for brightness, contrast, satuaration, 0 hue
T += [A.ColorJitter(*color_jitter, 0)]
else: # Use fixed crop for eval set (reproducibility)
T = [A.SmallestMaxSize(max_size=size), A.CenterCrop(height=size, width=size)]
T += [A.Normalize(mean=mean, std=std), ToTensorV2()] # Normalize and convert to Tensor
LOGGER.info(prefix + ', '.join(f'{x}'.replace('always_apply=False, ', '') for x in T if x.p))
return A.Compose(T)
except ImportError: # package not installed, skip
pass
except Exception as e:
LOGGER.info(f'{prefix}{e}')
def classify_transforms(size=224):
# Transforms to apply if albumentations not installed
return T.Compose([T.ToTensor(), T.Resize(size), T.CenterCrop(size), T.Normalize(IMAGENET_MEAN, IMAGENET_STD)])
| 14,671 | Python | .py | 283 | 42.431095 | 118 | 0.569324 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,522 | plots.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/plots.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Plotting utils
"""
import math
import os
from copy import copy
from pathlib import Path
from urllib.error import URLError
import cv2
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sn
import torch
from PIL import Image, ImageDraw, ImageFont
from utils.general import (CONFIG_DIR, FONT, LOGGER, Timeout, check_font, check_requirements, clip_coords,
increment_path, is_ascii, threaded, try_except, xywh2xyxy, xyxy2xywh)
from utils.metrics import fitness
# Settings
RANK = int(os.getenv('RANK', -1))
matplotlib.rc('font', **{'size': 11})
matplotlib.use('Agg') # for writing to files only
class Colors:
# Ultralytics color palette https://ultralytics.com/
def __init__(self):
# hex = matplotlib.colors.TABLEAU_COLORS.values()
hexs = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
'2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
self.palette = [self.hex2rgb(f'#{c}') for c in hexs]
self.n = len(self.palette)
def __call__(self, i, bgr=False):
c = self.palette[int(i) % self.n]
return (c[2], c[1], c[0]) if bgr else c
@staticmethod
def hex2rgb(h): # rgb order (PIL)
return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
colors = Colors() # create instance for 'from utils.plots import colors'
def check_pil_font(font=FONT, size=10):
# Return a PIL TrueType Font, downloading to CONFIG_DIR if necessary
font = Path(font)
font = font if font.exists() else (CONFIG_DIR / font.name)
try:
return ImageFont.truetype(str(font) if font.exists() else font.name, size)
except Exception: # download if missing
try:
check_font(font)
return ImageFont.truetype(str(font), size)
except TypeError:
check_requirements('Pillow>=8.4.0') # known issue https://github.com/ultralytics/yolov5/issues/5374
except URLError: # not online
return ImageFont.load_default()
class Annotator:
# YOLOv5 Annotator for train/val mosaics and jpgs and detect/hub inference annotations
def __init__(self, im, line_width=None, font_size=None, font='Arial.ttf', pil=False, example='abc'):
assert im.data.contiguous, 'Image not contiguous. Apply np.ascontiguousarray(im) to Annotator() input images.'
non_ascii = not is_ascii(example) # non-latin labels, i.e. asian, arabic, cyrillic
self.pil = pil or non_ascii
if self.pil: # use PIL
self.im = im if isinstance(im, Image.Image) else Image.fromarray(im)
self.draw = ImageDraw.Draw(self.im)
self.font = check_pil_font(font='Arial.Unicode.ttf' if non_ascii else font,
size=font_size or max(round(sum(self.im.size) / 2 * 0.035), 12))
else: # use cv2
self.im = im
self.lw = line_width or max(round(sum(im.shape) / 2 * 0.003), 2) # line width
def box_label(self, box, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):
# Add one xyxy box to image with label
if self.pil or not is_ascii(label):
self.draw.rectangle(box, width=self.lw, outline=color) # box
if label:
w, h = self.font.getsize(label) # text width, height
outside = box[1] - h >= 0 # label fits outside box
self.draw.rectangle(
(box[0], box[1] - h if outside else box[1], box[0] + w + 1,
box[1] + 1 if outside else box[1] + h + 1),
fill=color,
)
# self.draw.text((box[0], box[1]), label, fill=txt_color, font=self.font, anchor='ls') # for PIL>8.0
self.draw.text((box[0], box[1] - h if outside else box[1]), label, fill=txt_color, font=self.font)
else: # cv2
p1, p2 = (int(box[0]), int(box[1])), (int(box[2]), int(box[3]))
cv2.rectangle(self.im, p1, p2, color, thickness=self.lw, lineType=cv2.LINE_AA)
if label:
tf = max(self.lw - 1, 1) # font thickness
w, h = cv2.getTextSize(label, 0, fontScale=self.lw / 3, thickness=tf)[0] # text width, height
outside = p1[1] - h >= 3
p2 = p1[0] + w, p1[1] - h - 3 if outside else p1[1] + h + 3
cv2.rectangle(self.im, p1, p2, color, -1, cv2.LINE_AA) # filled
cv2.putText(self.im,
label, (p1[0], p1[1] - 2 if outside else p1[1] + h + 2),
0,
self.lw / 3,
txt_color,
thickness=tf,
lineType=cv2.LINE_AA)
def rectangle(self, xy, fill=None, outline=None, width=1):
# Add rectangle to image (PIL-only)
self.draw.rectangle(xy, fill, outline, width)
def text(self, xy, text, txt_color=(255, 255, 255)):
# Add text to image (PIL-only)
w, h = self.font.getsize(text) # text width, height
self.draw.text((xy[0], xy[1] - h + 1), text, fill=txt_color, font=self.font)
def result(self):
# Return annotated image as array
return np.asarray(self.im)
def feature_visualization(x, module_type, stage, n=32, save_dir=Path('runs/detect/exp')):
"""
x: Features to be visualized
module_type: Module type
stage: Module stage within model
n: Maximum number of feature maps to plot
save_dir: Directory to save results
"""
if 'Detect' not in module_type:
batch, channels, height, width = x.shape # batch, channels, height, width
if height > 1 and width > 1:
f = save_dir / f"stage{stage}_{module_type.split('.')[-1]}_features.png" # filename
blocks = torch.chunk(x[0].cpu(), channels, dim=0) # select batch index 0, block by channels
n = min(n, channels) # number of plots
fig, ax = plt.subplots(math.ceil(n / 8), 8, tight_layout=True) # 8 rows x n/8 cols
ax = ax.ravel()
plt.subplots_adjust(wspace=0.05, hspace=0.05)
for i in range(n):
ax[i].imshow(blocks[i].squeeze()) # cmap='gray'
ax[i].axis('off')
LOGGER.info(f'Saving {f}... ({n}/{channels})')
plt.title('Features')
plt.savefig(f, dpi=300, bbox_inches='tight')
plt.close()
np.save(str(f.with_suffix('.npy')), x[0].cpu().numpy()) # npy save
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):
from scipy.signal import butter, filtfilt
# 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
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)
@threaded
def plot_images(images, targets, paths=None, fname='images.jpg', names=None, max_size=1920, 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()
if np.max(images[0]) <= 1:
images *= 255 # de-normalise (optional)
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)
# Build Image
mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init
for i, im in enumerate(images):
if i == max_subplots: # if last batch has fewer images than we expect
break
x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
im = im.transpose(1, 2, 0)
mosaic[y:y + h, x:x + w, :] = im
# Resize (optional)
scale = max_size / ns / max(h, w)
if scale < 1:
h = math.ceil(scale * h)
w = math.ceil(scale * w)
mosaic = cv2.resize(mosaic, tuple(int(x * ns) for x in (w, h)))
# Annotate
fs = int((h + w) * ns * 0.01) # font size
annotator = Annotator(mosaic, line_width=round(fs / 10), font_size=fs, pil=True, example=names)
for i in range(i + 1):
x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
annotator.rectangle([x, y, x + w, y + h], None, (255, 255, 255), width=2) # borders
if paths:
annotator.text((x + 5, y + 5 + h), text=Path(paths[i]).name[:40], txt_color=(220, 220, 220)) # filenames
if len(targets) > 0:
ti = targets[targets[:, 0] == i] # image targets
boxes = xywh2xyxy(ti[:, 2:6]).T
classes = ti[:, 1].astype('int')
labels = ti.shape[1] == 6 # labels if no conf column
conf = None if labels else ti[:, 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 < 1: # absolute coords need scale if image scales
boxes *= scale
boxes[[0, 2]] += x
boxes[[1, 3]] += y
for j, box in enumerate(boxes.T.tolist()):
cls = classes[j]
color = colors(cls)
cls = names[cls] if names else cls
if labels or conf[j] > 0.25: # 0.25 conf thresh
label = f'{cls}' if labels else f'{cls} {conf[j]:.1f}'
annotator.box_label(box, label, color=color)
annotator.im.save(fname) # save
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_val_txt(): # from utils.plots import *; plot_val()
# Plot val.txt histograms
x = np.loadtxt('val.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=f'{x[i].mean():.3g} +/- {x[i].std():.3g}')
ax[i].legend()
ax[i].set_title(s[i])
plt.savefig('targets.jpg', dpi=200)
def plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()
# Plot file=study.txt generated by val.py (or plot all study*.txt in dir)
save_dir = Path(file).parent if file else Path(dir)
plot2 = False # plot additional results
if plot2:
ax = plt.subplots(2, 4, figsize=(10, 6), tight_layout=True)[1].ravel()
fig2, ax2 = plt.subplots(1, 1, figsize=(8, 4), tight_layout=True)
# for f in [save_dir / f'study_coco_{x}.txt' for x in ['yolov5n6', 'yolov5s6', 'yolov5m6', 'yolov5l6', 'yolov5x6']]:
for f in sorted(save_dir.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)
if plot2:
s = ['P', 'R', '[email protected]', '[email protected]:.95', 't_preprocess (ms/img)', 't_inference (ms/img)', 't_NMS (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[5, 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(25, 55)
ax2.set_xlabel('GPU Speed (ms/img)')
ax2.set_ylabel('COCO AP val')
ax2.legend(loc='lower right')
f = save_dir / 'study.png'
print(f'Saving {f}...')
plt.savefig(f, dpi=300)
@try_except # known issue https://github.com/ultralytics/yolov5/issues/5395
@Timeout(30) # known issue https://github.com/ultralytics/yolov5/issues/5611
def plot_labels(labels, names=(), save_dir=Path('')):
# plot dataset labels
LOGGER.info(f"Plotting labels to {save_dir / 'labels.jpg'}... ")
c, b = labels[:, 0], labels[:, 1:].transpose() # classes, boxes
nc = int(c.max() + 1) # number of classes
x = pd.DataFrame(b.transpose(), columns=['x', 'y', 'width', 'height'])
# seaborn correlogram
sn.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()
y = ax[0].hist(c, bins=np.linspace(0, nc, nc + 1) - 0.5, rwidth=0.8)
try: # color histogram bars by class
[y[2].patches[i].set_color([x / 255 for x in colors(i)]) for i in range(nc)] # known issue #3195
except Exception:
pass
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')
sn.histplot(x, x='x', y='y', ax=ax[2], bins=50, pmax=0.9)
sn.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(cls)) # 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()
def imshow_cls(im, labels=None, pred=None, names=None, nmax=25, verbose=False, f=Path('images.jpg')):
# Show classification image grid with labels (optional) and predictions (optional)
from utils.augmentations import denormalize
names = names or [f'class{i}' for i in range(1000)]
blocks = torch.chunk(denormalize(im.clone()).cpu().float(), len(im),
dim=0) # select batch index 0, block by channels
n = min(len(blocks), nmax) # number of plots
m = min(8, round(n ** 0.5)) # 8 x 8 default
fig, ax = plt.subplots(math.ceil(n / m), m) # 8 rows x n/8 cols
ax = ax.ravel() if m > 1 else [ax]
# plt.subplots_adjust(wspace=0.05, hspace=0.05)
for i in range(n):
ax[i].imshow(blocks[i].squeeze().permute((1, 2, 0)).numpy().clip(0.0, 1.0))
ax[i].axis('off')
if labels is not None:
s = names[labels[i]] + (f'—{names[pred[i]]}' if pred is not None else '')
ax[i].set_title(s, fontsize=8, verticalalignment='top')
plt.savefig(f, dpi=300, bbox_inches='tight')
plt.close()
if verbose:
LOGGER.info(f"Saving {f}")
if labels is not None:
LOGGER.info('True: ' + ' '.join(f'{names[i]:3s}' for i in labels[:nmax]))
if pred is not None:
LOGGER.info('Predicted:' + ' '.join(f'{names[i]:3s}' for i in pred[:nmax]))
return f
def plot_evolve(evolve_csv='path/to/evolve.csv'): # from utils.plots import *; plot_evolve()
# Plot evolve.csv hyp evolution results
evolve_csv = Path(evolve_csv)
data = pd.read_csv(evolve_csv)
keys = [x.strip() for x in data.columns]
x = data.values
f = fitness(x)
j = np.argmax(f) # max fitness index
plt.figure(figsize=(10, 12), tight_layout=True)
matplotlib.rc('font', **{'size': 8})
print(f'Best results from row {j} of {evolve_csv}:')
for i, k in enumerate(keys[7:]):
v = x[:, 7 + i]
mu = v[j] # best single result
plt.subplot(6, 5, i + 1)
plt.scatter(v, f, c=hist2d(v, f, 20), cmap='viridis', alpha=.8, edgecolors='none')
plt.plot(mu, f.max(), 'k+', markersize=15)
plt.title(f'{k} = {mu:.3g}', fontdict={'size': 9}) # limit to 40 characters
if i % 5 != 0:
plt.yticks([])
print(f'{k:>15}: {mu:.3g}')
f = evolve_csv.with_suffix('.png') # filename
plt.savefig(f, dpi=200)
plt.close()
print(f'Saved {f}')
def plot_results(file='path/to/results.csv', dir=''):
# Plot training results.csv. Usage: from utils.plots import *; plot_results('path/to/results.csv')
save_dir = Path(file).parent if file else Path(dir)
fig, ax = plt.subplots(2, 5, figsize=(12, 6), tight_layout=True)
ax = ax.ravel()
files = list(save_dir.glob('results*.csv'))
assert len(files), f'No results.csv files found in {save_dir.resolve()}, nothing to plot.'
for f in files:
try:
data = pd.read_csv(f)
s = [x.strip() for x in data.columns]
x = data.values[:, 0]
for i, j in enumerate([1, 2, 3, 4, 5, 8, 9, 10, 6, 7]):
y = data.values[:, j].astype('float')
# y[y == 0] = np.nan # don't show zero values
ax[i].plot(x, y, marker='.', label=f.stem, linewidth=2, markersize=8)
ax[i].set_title(s[j], fontsize=12)
# if j in [8, 9, 10]: # share train and val loss y axes
# ax[i].get_shared_y_axes().join(ax[i], ax[i - 5])
except Exception as e:
LOGGER.info(f'Warning: Plotting error for {f}: {e}')
ax[1].legend()
fig.savefig(save_dir / 'results.png', dpi=200)
plt.close()
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(f'Warning: Plotting error for {f}; {e}')
ax[1].legend()
plt.savefig(Path(save_dir) / 'idetection_profile.png', dpi=200)
def save_one_box(xyxy, im, file=Path('im.jpg'), gain=1.02, pad=10, square=False, BGR=False, save=True):
# Save image crop as {file} with crop size multiple {gain} and {pad} pixels. Save and/or return crop
xyxy = torch.tensor(xyxy).view(-1, 4)
b = xyxy2xywh(xyxy) # boxes
if square:
b[:, 2:] = b[:, 2:].max(1)[0].unsqueeze(1) # attempt rectangle to square
b[:, 2:] = b[:, 2:] * gain + pad # box wh * gain + pad
xyxy = xywh2xyxy(b).long()
clip_coords(xyxy, im.shape)
crop = im[int(xyxy[0, 1]):int(xyxy[0, 3]), int(xyxy[0, 0]):int(xyxy[0, 2]), ::(1 if BGR else -1)]
if save:
file.parent.mkdir(parents=True, exist_ok=True) # make directory
f = str(increment_path(file).with_suffix('.jpg'))
# cv2.imwrite(f, crop) # save BGR, https://github.com/ultralytics/yolov5/issues/7007 chroma subsampling issue
Image.fromarray(crop[..., ::-1]).save(f, quality=95, subsampling=0) # save RGB
return crop
| 22,445 | Python | .py | 451 | 41.028825 | 120 | 0.575071 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,523 | metrics.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/metrics.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Model validation metrics
"""
import math
import warnings
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import torch
def fitness(x):
# Model fitness as a weighted combination of metrics
w = [0.0, 0.0, 0.1, 0.9] # weights for [P, R, [email protected], [email protected]:0.95]
return (x[:, :4] * w).sum(1)
def smooth(y, f=0.05):
# Box filter of fraction f
nf = round(len(y) * f * 2) // 2 + 1 # number of filter elements (must be odd)
p = np.ones(nf // 2) # ones padding
yp = np.concatenate((p * y[0], y, p * y[-1]), 0) # y padded
return np.convolve(yp, np.ones(nf) / nf, mode='valid') # y-smoothed
def ap_per_class(tp, conf, pred_cls, target_cls, plot=False, save_dir='.', names=(), eps=1e-16):
""" Compute the average precision, given the recall and precision curves.
Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
# Arguments
tp: True positives (nparray, nx1 or nx10).
conf: Objectness value from 0-1 (nparray).
pred_cls: Predicted object classes (nparray).
target_cls: True object classes (nparray).
plot: Plot precision-recall curve at [email protected]
save_dir: Plot save directory
# Returns
The average precision as computed in py-faster-rcnn.
"""
# Sort by objectness
i = np.argsort(-conf)
tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]
# Find unique classes
unique_classes, nt = np.unique(target_cls, return_counts=True)
nc = unique_classes.shape[0] # number of classes, number of detections
# Create Precision-Recall curve and compute AP for each class
px, py = np.linspace(0, 1, 1000), [] # for plotting
ap, p, r = np.zeros((nc, tp.shape[1])), np.zeros((nc, 1000)), np.zeros((nc, 1000))
for ci, c in enumerate(unique_classes):
i = pred_cls == c
n_l = nt[ci] # number of labels
n_p = i.sum() # number of predictions
if n_p == 0 or n_l == 0:
continue
# Accumulate FPs and TPs
fpc = (1 - tp[i]).cumsum(0)
tpc = tp[i].cumsum(0)
# Recall
recall = tpc / (n_l + eps) # recall curve
r[ci] = np.interp(-px, -conf[i], recall[:, 0], left=0) # negative x, xp because xp decreases
# Precision
precision = tpc / (tpc + fpc) # precision curve
p[ci] = np.interp(-px, -conf[i], precision[:, 0], left=1) # p at pr_score
# AP from recall-precision curve
for j in range(tp.shape[1]):
ap[ci, j], mpre, mrec = compute_ap(recall[:, j], precision[:, j])
if plot and j == 0:
py.append(np.interp(px, mrec, mpre)) # precision at [email protected]
# Compute F1 (harmonic mean of precision and recall)
f1 = 2 * p * r / (p + r + eps)
names = [v for k, v in names.items() if k in unique_classes] # list: only classes that have data
names = dict(enumerate(names)) # to dict
if plot:
plot_pr_curve(px, py, ap, Path(save_dir) / 'PR_curve.png', names)
plot_mc_curve(px, f1, Path(save_dir) / 'F1_curve.png', names, ylabel='F1')
plot_mc_curve(px, p, Path(save_dir) / 'P_curve.png', names, ylabel='Precision')
plot_mc_curve(px, r, Path(save_dir) / 'R_curve.png', names, ylabel='Recall')
i = smooth(f1.mean(0), 0.1).argmax() # max F1 index
p, r, f1 = p[:, i], r[:, i], f1[:, i]
tp = (r * nt).round() # true positives
fp = (tp / (p + eps) - tp).round() # false positives
return tp, fp, p, r, f1, ap, unique_classes.astype(int)
def compute_ap(recall, precision):
""" Compute the average precision, given the recall and precision curves
# Arguments
recall: The recall curve (list)
precision: The precision curve (list)
# Returns
Average precision, precision curve, recall curve
"""
# Append sentinel values to beginning and end
mrec = np.concatenate(([0.0], recall, [1.0]))
mpre = np.concatenate(([1.0], precision, [0.0]))
# Compute the precision envelope
mpre = np.flip(np.maximum.accumulate(np.flip(mpre)))
# Integrate area under curve
method = 'interp' # methods: 'continuous', 'interp'
if method == 'interp':
x = np.linspace(0, 1, 101) # 101-point interp (COCO)
ap = np.trapz(np.interp(x, mrec, mpre), x) # integrate
else: # 'continuous'
i = np.where(mrec[1:] != mrec[:-1])[0] # points where x axis (recall) changes
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) # area under curve
return ap, mpre, mrec
class ConfusionMatrix:
# Updated version of https://github.com/kaanakan/object_detection_confusion_matrix
def __init__(self, nc, conf=0.25, iou_thres=0.45):
self.matrix = np.zeros((nc + 1, nc + 1))
self.nc = nc # number of classes
self.conf = conf
self.iou_thres = iou_thres
def process_batch(self, detections, labels):
"""
Return intersection-over-union (Jaccard index) of boxes.
Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
Arguments:
detections (Array[N, 6]), x1, y1, x2, y2, conf, class
labels (Array[M, 5]), class, x1, y1, x2, y2
Returns:
None, updates confusion matrix accordingly
"""
if detections is None:
gt_classes = labels.int()
for i, gc in enumerate(gt_classes):
self.matrix[self.nc, gc] += 1 # background FN
return
detections = detections[detections[:, 4] > self.conf]
gt_classes = labels[:, 0].int()
detection_classes = detections[:, 5].int()
iou = box_iou(labels[:, 1:], detections[:, :4])
x = torch.where(iou > self.iou_thres)
if x[0].shape[0]:
matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()
if x[0].shape[0] > 1:
matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
else:
matches = np.zeros((0, 3))
n = matches.shape[0] > 0
m0, m1, _ = matches.transpose().astype(int)
for i, gc in enumerate(gt_classes):
j = m0 == i
if n and sum(j) == 1:
self.matrix[detection_classes[m1[j]], gc] += 1 # correct
else:
self.matrix[self.nc, gc] += 1 # background FP
if n:
for i, dc in enumerate(detection_classes):
if not any(m1 == i):
self.matrix[dc, self.nc] += 1 # background FN
def matrix(self):
return self.matrix
def tp_fp(self):
tp = self.matrix.diagonal() # true positives
fp = self.matrix.sum(1) - tp # false positives
# fn = self.matrix.sum(0) - tp # false negatives (missed detections)
return tp[:-1], fp[:-1] # remove background class
def plot(self, normalize=True, save_dir='', names=()):
try:
import seaborn as sn
array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1E-9) if normalize else 1) # normalize columns
array[array < 0.005] = np.nan # don't annotate (would appear as 0.00)
fig = plt.figure(figsize=(12, 9), tight_layout=True)
nc, nn = self.nc, len(names) # number of classes, names
sn.set(font_scale=1.0 if nc < 50 else 0.8) # for label size
labels = (0 < nn < 99) and (nn == nc) # apply names to ticklabels
with warnings.catch_warnings():
warnings.simplefilter('ignore') # suppress empty matrix RuntimeWarning: All-NaN slice encountered
sn.heatmap(array,
annot=nc < 30,
annot_kws={
"size": 8},
cmap='Blues',
fmt='.2f',
square=True,
vmin=0.0,
xticklabels=names + ['background FP'] if labels else "auto",
yticklabels=names + ['background FN'] if labels else "auto").set_facecolor((1, 1, 1))
fig.axes[0].set_xlabel('True')
fig.axes[0].set_ylabel('Predicted')
plt.title('Confusion Matrix')
fig.savefig(Path(save_dir) / 'confusion_matrix.png', dpi=250)
plt.close()
except Exception as e:
print(f'WARNING: ConfusionMatrix plot failure: {e}')
def print(self):
for i in range(self.nc + 1):
print(' '.join(map(str, self.matrix[i])))
def bbox_iou(box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7):
# Returns Intersection over Union (IoU) of box1(1,4) to box2(n,4)
# Get the coordinates of bounding boxes
if xywh: # transform from xywh to xyxy
(x1, y1, w1, h1), (x2, y2, w2, h2) = box1.chunk(4, 1), box2.chunk(4, 1)
w1_, h1_, w2_, h2_ = w1 / 2, h1 / 2, w2 / 2, h2 / 2
b1_x1, b1_x2, b1_y1, b1_y2 = x1 - w1_, x1 + w1_, y1 - h1_, y1 + h1_
b2_x1, b2_x2, b2_y1, b2_y2 = x2 - w2_, x2 + w2_, y2 - h2_, y2 + h2_
else: # x1, y1, x2, y2 = box1
b1_x1, b1_y1, b1_x2, b1_y2 = box1.chunk(4, 1)
b2_x1, b2_y1, b2_x2, b2_y2 = box2.chunk(4, 1)
w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1
w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1
# Intersection area
inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
(torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)
# Union Area
union = w1 * h1 + w2 * h2 - inter + eps
# IoU
iou = inter / union
if CIoU or DIoU or GIoU:
cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1) # convex (smallest enclosing box) width
ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height
if CIoU or DIoU: # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
c2 = cw ** 2 + ch ** 2 + eps # convex diagonal squared
rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4 # center dist ** 2
if CIoU: # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / (h2 + eps)) - torch.atan(w1 / (h1 + eps)), 2)
with torch.no_grad():
alpha = v / (v - iou + (1 + eps))
return iou - (rho2 / c2 + v * alpha) # CIoU
return iou - rho2 / c2 # DIoU
c_area = cw * ch + eps # convex area
return iou - (c_area - union) / c_area # GIoU https://arxiv.org/pdf/1902.09630.pdf
return iou # IoU
def box_area(box):
# box = xyxy(4,n)
return (box[2] - box[0]) * (box[3] - box[1])
def box_iou(box1, box2, eps=1e-7):
# https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
"""
Return intersection-over-union (Jaccard index) of boxes.
Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
Arguments:
box1 (Tensor[N, 4])
box2 (Tensor[M, 4])
Returns:
iou (Tensor[N, M]): the NxM matrix containing the pairwise
IoU values for every element in boxes1 and boxes2
"""
# inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
(a1, a2), (b1, b2) = box1[:, None].chunk(2, 2), box2.chunk(2, 1)
inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp(0).prod(2)
# IoU = inter / (area1 + area2 - inter)
return inter / (box_area(box1.T)[:, None] + box_area(box2.T) - inter + eps)
def bbox_ioa(box1, box2, eps=1e-7):
""" Returns the intersection over box2 area given box1, box2. Boxes are x1y1x2y2
box1: np.array of shape(4)
box2: np.array of shape(nx4)
returns: np.array of shape(n)
"""
# Get the coordinates of bounding boxes
b1_x1, b1_y1, b1_x2, b1_y2 = box1
b2_x1, b2_y1, b2_x2, b2_y2 = box2.T
# Intersection area
inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \
(np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0)
# box2 area
box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + eps
# Intersection over box2 area
return inter_area / box2_area
def wh_iou(wh1, wh2, eps=1e-7):
# Returns the nxm IoU matrix. wh1 is nx2, wh2 is mx2
wh1 = wh1[:, None] # [N,1,2]
wh2 = wh2[None] # [1,M,2]
inter = torch.min(wh1, wh2).prod(2) # [N,M]
return inter / (wh1.prod(2) + wh2.prod(2) - inter + eps) # iou = inter / (area1 + area2 - inter)
# Plots ----------------------------------------------------------------------------------------------------------------
def plot_pr_curve(px, py, ap, save_dir=Path('pr_curve.png'), names=()):
# Precision-recall curve
fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
py = np.stack(py, axis=1)
if 0 < len(names) < 21: # display per-class legend if < 21 classes
for i, y in enumerate(py.T):
ax.plot(px, y, linewidth=1, label=f'{names[i]} {ap[i, 0]:.3f}') # plot(recall, precision)
else:
ax.plot(px, py, linewidth=1, color='grey') # plot(recall, precision)
ax.plot(px, py.mean(1), linewidth=3, color='blue', label='all classes %.3f [email protected]' % ap[:, 0].mean())
ax.set_xlabel('Recall')
ax.set_ylabel('Precision')
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
plt.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
plt.title('Precision-Recall Curve')
fig.savefig(save_dir, dpi=250)
plt.close()
def plot_mc_curve(px, py, save_dir=Path('mc_curve.png'), names=(), xlabel='Confidence', ylabel='Metric'):
# Metric-confidence curve
fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
if 0 < len(names) < 21: # display per-class legend if < 21 classes
for i, y in enumerate(py):
ax.plot(px, y, linewidth=1, label=f'{names[i]}') # plot(confidence, metric)
else:
ax.plot(px, py.T, linewidth=1, color='grey') # plot(confidence, metric)
y = smooth(py.mean(0), 0.05)
ax.plot(px, y, linewidth=3, color='blue', label=f'all classes {y.max():.2f} at {px[y.argmax()]:.3f}')
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
plt.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
plt.title(f'{ylabel}-Confidence Curve')
fig.savefig(save_dir, dpi=250)
plt.close()
| 14,723 | Python | .py | 298 | 40.909396 | 120 | 0.56731 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,524 | downloads.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/downloads.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Download utils
"""
import logging
import os
import platform
import subprocess
import time
import urllib
from pathlib import Path
from zipfile import ZipFile
import requests
import torch
def is_url(url, check_online=True):
# Check if online file exists
try:
url = str(url)
result = urllib.parse.urlparse(url)
assert all([result.scheme, result.netloc, result.path]) # check if is url
return (urllib.request.urlopen(url).getcode() == 200) if check_online else True # check if exists online
except (AssertionError, urllib.request.HTTPError):
return False
def gsutil_getsize(url=''):
# gs://bucket/file size https://cloud.google.com/storage/docs/gsutil/commands/du
s = subprocess.check_output(f'gsutil du {url}', shell=True).decode('utf-8')
return eval(s.split(' ')[0]) if len(s) else 0 # bytes
def safe_download(file, url, url2=None, min_bytes=1E0, error_msg=''):
# Attempts to download file from url or url2, checks and removes incomplete downloads < min_bytes
from utils.general import LOGGER
file = Path(file)
assert_msg = f"Downloaded file '{file}' does not exist or size is < min_bytes={min_bytes}"
try: # url1
LOGGER.info(f'Downloading {url} to {file}...')
torch.hub.download_url_to_file(url, str(file), progress=LOGGER.level <= logging.INFO)
assert file.exists() and file.stat().st_size > min_bytes, assert_msg # check
except Exception as e: # url2
file.unlink(missing_ok=True) # remove partial downloads
LOGGER.info(f'ERROR: {e}\nRe-attempting {url2 or url} to {file}...')
os.system(f"curl -L '{url2 or url}' -o '{file}' --retry 3 -C -") # curl download, retry and resume on fail
finally:
if not file.exists() or file.stat().st_size < min_bytes: # check
file.unlink(missing_ok=True) # remove partial downloads
LOGGER.info(f"ERROR: {assert_msg}\n{error_msg}")
LOGGER.info('')
def attempt_download(file, repo='ultralytics/yolov5', release='v6.1'):
# Attempt file download from GitHub release assets if not found locally. release = 'latest', 'v6.1', etc.
from utils.general import LOGGER
def github_assets(repository, version='latest'):
# Return GitHub repo tag (i.e. 'v6.1') and assets (i.e. ['yolov5s.pt', 'yolov5m.pt', ...])
if version != 'latest':
version = f'tags/{version}' # i.e. tags/v6.1
response = requests.get(f'https://api.github.com/repos/{repository}/releases/{version}').json() # github api
return response['tag_name'], [x['name'] for x in response['assets']] # tag, assets
file = Path(str(file).strip().replace("'", ''))
if not file.exists():
# URL specified
name = Path(urllib.parse.unquote(str(file))).name # decode '%2F' to '/' etc.
if str(file).startswith(('http:/', 'https:/')): # download
url = str(file).replace(':/', '://') # Pathlib turns :// -> :/
file = name.split('?')[0] # parse authentication https://url.com/file.txt?auth...
if Path(file).is_file():
LOGGER.info(f'Found {url} locally at {file}') # file already exists
else:
safe_download(file=file, url=url, min_bytes=1E5)
return file
# GitHub assets
assets = [
'yolov5n.pt', 'yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt', 'yolov5n6.pt', 'yolov5s6.pt',
'yolov5m6.pt', 'yolov5l6.pt', 'yolov5x6.pt']
try:
tag, assets = github_assets(repo, release)
except Exception:
try:
tag, assets = github_assets(repo) # latest release
except Exception:
try:
tag = subprocess.check_output('git tag', shell=True, stderr=subprocess.STDOUT).decode().split()[-1]
except Exception:
tag = release
file.parent.mkdir(parents=True, exist_ok=True) # make parent dir (if required)
if name in assets:
url3 = 'https://drive.google.com/drive/folders/1EFQTEUeXWSFww0luse2jB9M1QNZQGwNl' # backup gdrive mirror
safe_download(
file,
url=f'https://github.com/{repo}/releases/download/{tag}/{name}',
url2=f'https://storage.googleapis.com/{repo}/{tag}/{name}', # backup url (optional)
min_bytes=1E5,
error_msg=f'{file} missing, try downloading from https://github.com/{repo}/releases/{tag} or {url3}')
return str(file)
def gdrive_download(id='16TiPfZj7htmTyhntwcZyEEAejOUxuT6m', file='tmp.zip'):
# Downloads a file from Google Drive. from yolov5.utils.downloads import *; gdrive_download()
t = time.time()
file = Path(file)
cookie = Path('cookie') # gdrive cookie
print(f'Downloading https://drive.google.com/uc?export=download&id={id} as {file}... ', end='')
file.unlink(missing_ok=True) # remove existing file
cookie.unlink(missing_ok=True) # remove existing cookie
# Attempt file download
out = "NUL" if platform.system() == "Windows" else "/dev/null"
os.system(f'curl -c ./cookie -s -L "drive.google.com/uc?export=download&id={id}" > {out}')
if os.path.exists('cookie'): # large file
s = f'curl -Lb ./cookie "drive.google.com/uc?export=download&confirm={get_token()}&id={id}" -o {file}'
else: # small file
s = f'curl -s -L -o {file} "drive.google.com/uc?export=download&id={id}"'
r = os.system(s) # execute, capture return
cookie.unlink(missing_ok=True) # remove existing cookie
# Error check
if r != 0:
file.unlink(missing_ok=True) # remove partial
print('Download error ') # raise Exception('Download error')
return r
# Unzip if archive
if file.suffix == '.zip':
print('unzipping... ', end='')
ZipFile(file).extractall(path=file.parent) # unzip
file.unlink() # remove zip
print(f'Done ({time.time() - t:.1f}s)')
return r
def get_token(cookie="./cookie"):
with open(cookie) as f:
for line in f:
if "download" in line:
return line.split()[-1]
return ""
# Google utils: https://cloud.google.com/storage/docs/reference/libraries ----------------------------------------------
#
#
# def upload_blob(bucket_name, source_file_name, destination_blob_name):
# # Uploads a file to a bucket
# # https://cloud.google.com/storage/docs/uploading-objects#storage-upload-object-python
#
# storage_client = storage.Client()
# bucket = storage_client.get_bucket(bucket_name)
# blob = bucket.blob(destination_blob_name)
#
# blob.upload_from_filename(source_file_name)
#
# print('File {} uploaded to {}.'.format(
# source_file_name,
# destination_blob_name))
#
#
# def download_blob(bucket_name, source_blob_name, destination_file_name):
# # Uploads a blob from a bucket
# storage_client = storage.Client()
# bucket = storage_client.get_bucket(bucket_name)
# blob = bucket.blob(source_blob_name)
#
# blob.download_to_filename(destination_file_name)
#
# print('Blob {} downloaded to {}.'.format(
# source_blob_name,
# destination_file_name))
| 7,326 | Python | .py | 154 | 40.87013 | 120 | 0.627764 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,525 | __init__.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/__init__.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
utils/initialization
"""
def notebook_init(verbose=True):
# Check system software and hardware
print('Checking setup...')
import os
import shutil
from utils.general import check_requirements, emojis, is_colab
from utils.torch_utils import select_device # imports
check_requirements(('psutil', 'IPython'))
import psutil
from IPython import display # to display images and clear console output
if is_colab():
shutil.rmtree('/content/sample_data', ignore_errors=True) # remove colab /sample_data directory
# System info
if verbose:
gb = 1 << 30 # bytes to GiB (1024 ** 3)
ram = psutil.virtual_memory().total
total, used, free = shutil.disk_usage("/")
display.clear_output()
s = f'({os.cpu_count()} CPUs, {ram / gb:.1f} GB RAM, {(total - free) / gb:.1f}/{total / gb:.1f} GB disk)'
else:
s = ''
select_device(newline=False)
print(emojis(f'Setup complete ✅ {s}'))
return display
| 1,057 | Python | .py | 28 | 32.178571 | 113 | 0.653281 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,526 | benchmarks.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/benchmarks.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Run YOLOv5 benchmarks on all supported export formats
Format | `export.py --include` | Model
--- | --- | ---
PyTorch | - | yolov5s.pt
TorchScript | `torchscript` | yolov5s.torchscript
ONNX | `onnx` | yolov5s.onnx
OpenVINO | `openvino` | yolov5s_openvino_model/
TensorRT | `engine` | yolov5s.engine
CoreML | `coreml` | yolov5s.mlmodel
TensorFlow SavedModel | `saved_model` | yolov5s_saved_model/
TensorFlow GraphDef | `pb` | yolov5s.pb
TensorFlow Lite | `tflite` | yolov5s.tflite
TensorFlow Edge TPU | `edgetpu` | yolov5s_edgetpu.tflite
TensorFlow.js | `tfjs` | yolov5s_web_model/
Requirements:
$ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime openvino-dev tensorflow-cpu # CPU
$ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime-gpu openvino-dev tensorflow # GPU
$ pip install -U nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com # TensorRT
Usage:
$ python utils/benchmarks.py --weights yolov5s.pt --img 640
"""
import argparse
import platform
import sys
import time
from pathlib import Path
import pandas as pd
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
# ROOT = ROOT.relative_to(Path.cwd()) # relative
import export
import val
from utils import notebook_init
from utils.general import LOGGER, check_yaml, file_size, print_args
from utils.torch_utils import select_device
def run(
weights=ROOT / 'yolov5s.pt', # weights path
imgsz=640, # inference size (pixels)
batch_size=1, # batch size
data=ROOT / 'data/coco128.yaml', # dataset.yaml path
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
half=False, # use FP16 half-precision inference
test=False, # test exports only
pt_only=False, # test PyTorch only
hard_fail=False, # throw error on benchmark failure
):
y, t = [], time.time()
device = select_device(device)
for i, (name, f, suffix, cpu, gpu) in export.export_formats().iterrows(): # index, (name, file, suffix, CPU, GPU)
try:
assert i not in (9, 10), 'inference not supported' # Edge TPU and TF.js are unsupported
assert i != 5 or platform.system() == 'Darwin', 'inference only supported on macOS>=10.13' # CoreML
if 'cpu' in device.type:
assert cpu, 'inference not supported on CPU'
if 'cuda' in device.type:
assert gpu, 'inference not supported on GPU'
# Export
if f == '-':
w = weights # PyTorch format
else:
w = export.run(weights=weights, imgsz=[imgsz], include=[f], device=device, half=half)[-1] # all others
assert suffix in str(w), 'export failed'
# Validate
result = val.run(data, w, batch_size, imgsz, plots=False, device=device, task='benchmark', half=half)
metrics = result[0] # metrics (mp, mr, map50, map, *losses(box, obj, cls))
speeds = result[2] # times (preprocess, inference, postprocess)
y.append([name, round(file_size(w), 1), round(metrics[3], 4), round(speeds[1], 2)]) # MB, mAP, t_inference
except Exception as e:
if hard_fail:
assert type(e) is AssertionError, f'Benchmark --hard-fail for {name}: {e}'
LOGGER.warning(f'WARNING: Benchmark failure for {name}: {e}')
y.append([name, None, None, None]) # mAP, t_inference
if pt_only and i == 0:
break # break after PyTorch
# Print results
LOGGER.info('\n')
parse_opt()
notebook_init() # print system info
c = ['Format', 'Size (MB)', '[email protected]:0.95', 'Inference time (ms)'] if map else ['Format', 'Export', '', '']
py = pd.DataFrame(y, columns=c)
LOGGER.info(f'\nBenchmarks complete ({time.time() - t:.2f}s)')
LOGGER.info(str(py if map else py.iloc[:, :2]))
return py
def test(
weights=ROOT / 'yolov5s.pt', # weights path
imgsz=640, # inference size (pixels)
batch_size=1, # batch size
data=ROOT / 'data/coco128.yaml', # dataset.yaml path
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
half=False, # use FP16 half-precision inference
test=False, # test exports only
pt_only=False, # test PyTorch only
hard_fail=False, # throw error on benchmark failure
):
y, t = [], time.time()
device = select_device(device)
for i, (name, f, suffix, gpu) in export.export_formats().iterrows(): # index, (name, file, suffix, gpu-capable)
try:
w = weights if f == '-' else \
export.run(weights=weights, imgsz=[imgsz], include=[f], device=device, half=half)[-1] # weights
assert suffix in str(w), 'export failed'
y.append([name, True])
except Exception:
y.append([name, False]) # mAP, t_inference
# Print results
LOGGER.info('\n')
parse_opt()
notebook_init() # print system info
py = pd.DataFrame(y, columns=['Format', 'Export'])
LOGGER.info(f'\nExports complete ({time.time() - t:.2f}s)')
LOGGER.info(str(py))
return py
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='weights path')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')
parser.add_argument('--batch-size', type=int, default=1, help='batch size')
parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--test', action='store_true', help='test exports only')
parser.add_argument('--pt-only', action='store_true', help='test PyTorch only')
parser.add_argument('--hard-fail', action='store_true', help='throw error on benchmark failure')
opt = parser.parse_args()
opt.data = check_yaml(opt.data) # check YAML
print_args(vars(opt))
return opt
def main(opt):
test(**vars(opt)) if opt.test else run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 6,958 | Python | .py | 136 | 44.772059 | 119 | 0.593589 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,527 | loss.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loss.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Loss functions
"""
import torch
import torch.nn as nn
from utils.metrics import bbox_iou
from utils.torch_utils import de_parallel
def smooth_BCE(eps=0.1): # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441
# return positive, negative label smoothing BCE targets
return 1.0 - 0.5 * eps, 0.5 * eps
class BCEBlurWithLogitsLoss(nn.Module):
# BCEwithLogitLoss() with reduced missing label effects.
def __init__(self, alpha=0.05):
super().__init__()
self.loss_fcn = nn.BCEWithLogitsLoss(reduction='none') # must be nn.BCEWithLogitsLoss()
self.alpha = alpha
def forward(self, pred, true):
loss = self.loss_fcn(pred, true)
pred = torch.sigmoid(pred) # prob from logits
dx = pred - true # reduce only missing label effects
# dx = (pred - true).abs() # reduce missing label and false label effects
alpha_factor = 1 - torch.exp((dx - 1) / (self.alpha + 1e-4))
loss *= alpha_factor
return loss.mean()
class FocalLoss(nn.Module):
# Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
super().__init__()
self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
self.gamma = gamma
self.alpha = alpha
self.reduction = loss_fcn.reduction
self.loss_fcn.reduction = 'none' # required to apply FL to each element
def forward(self, pred, true):
loss = self.loss_fcn(pred, true)
# p_t = torch.exp(-loss)
# loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power for gradient stability
# TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py
pred_prob = torch.sigmoid(pred) # prob from logits
p_t = true * pred_prob + (1 - true) * (1 - pred_prob)
alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
modulating_factor = (1.0 - p_t) ** self.gamma
loss *= alpha_factor * modulating_factor
if self.reduction == 'mean':
return loss.mean()
elif self.reduction == 'sum':
return loss.sum()
else: # 'none'
return loss
class QFocalLoss(nn.Module):
# Wraps Quality focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
super().__init__()
self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
self.gamma = gamma
self.alpha = alpha
self.reduction = loss_fcn.reduction
self.loss_fcn.reduction = 'none' # required to apply FL to each element
def forward(self, pred, true):
loss = self.loss_fcn(pred, true)
pred_prob = torch.sigmoid(pred) # prob from logits
alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
modulating_factor = torch.abs(true - pred_prob) ** self.gamma
loss *= alpha_factor * modulating_factor
if self.reduction == 'mean':
return loss.mean()
elif self.reduction == 'sum':
return loss.sum()
else: # 'none'
return loss
class ComputeLoss:
sort_obj_iou = False
# Compute losses
def __init__(self, model, autobalance=False):
device = next(model.parameters()).device # get model device
h = model.hyp # hyperparameters
# Define criteria
BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
# Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
# Focal loss
g = h['fl_gamma'] # focal loss gamma
if g > 0:
BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
m = de_parallel(model).model[-1] # Detect() module
self.balance = {3: [4.0, 1.0, 0.4]}.get(m.nl, [4.0, 1.0, 0.25, 0.06, 0.02]) # P3-P7
self.ssi = list(m.stride).index(16) if autobalance else 0 # stride 16 index
self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, 1.0, h, autobalance
self.na = m.na # number of anchors
self.nc = m.nc # number of classes
self.nl = m.nl # number of layers
self.anchors = m.anchors
self.device = device
def __call__(self, p, targets): # predictions, targets
lcls = torch.zeros(1, device=self.device) # class loss
lbox = torch.zeros(1, device=self.device) # box loss
lobj = torch.zeros(1, device=self.device) # object loss
tcls, tbox, indices, anchors = self.build_targets(p, targets) # targets
# Losses
for i, pi in enumerate(p): # layer index, layer predictions
b, a, gj, gi = indices[i] # image, anchor, gridy, gridx
tobj = torch.zeros(pi.shape[:4], dtype=pi.dtype, device=self.device) # target obj
n = b.shape[0] # number of targets
if n:
# pxy, pwh, _, pcls = pi[b, a, gj, gi].tensor_split((2, 4, 5), dim=1) # faster, requires torch 1.8.0
pxy, pwh, _, pcls = pi[b, a, gj, gi].split((2, 2, 1, self.nc), 1) # target-subset of predictions
# Regression
pxy = pxy.sigmoid() * 2 - 0.5
pwh = (pwh.sigmoid() * 2) ** 2 * anchors[i]
pbox = torch.cat((pxy, pwh), 1) # predicted box
iou = bbox_iou(pbox, tbox[i], CIoU=True).squeeze() # iou(prediction, target)
lbox += (1.0 - iou).mean() # iou loss
# Objectness
iou = iou.detach().clamp(0).type(tobj.dtype)
if self.sort_obj_iou:
j = iou.argsort()
b, a, gj, gi, iou = b[j], a[j], gj[j], gi[j], iou[j]
if self.gr < 1:
iou = (1.0 - self.gr) + self.gr * iou
tobj[b, a, gj, gi] = iou # iou ratio
# Classification
if self.nc > 1: # cls loss (only if multiple classes)
t = torch.full_like(pcls, self.cn, device=self.device) # targets
t[range(n), tcls[i]] = self.cp
lcls += self.BCEcls(pcls, t) # BCE
# Append targets to text file
# with open('targets.txt', 'a') as file:
# [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
obji = self.BCEobj(pi[..., 4], tobj)
lobj += obji * self.balance[i] # obj loss
if self.autobalance:
self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
if self.autobalance:
self.balance = [x / self.balance[self.ssi] for x in self.balance]
lbox *= self.hyp['box']
lobj *= self.hyp['obj']
lcls *= self.hyp['cls']
bs = tobj.shape[0] # batch size
return (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach()
def build_targets(self, p, targets):
# Build targets for compute_loss(), input targets(image,class,x,y,w,h)
na, nt = self.na, targets.shape[0] # number of anchors, targets
tcls, tbox, indices, anch = [], [], [], []
gain = torch.ones(7, device=self.device) # normalized to gridspace gain
ai = torch.arange(na, device=self.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
targets = torch.cat((targets.repeat(na, 1, 1), ai[..., None]), 2) # append anchor indices
g = 0.5 # bias
off = torch.tensor(
[
[0, 0],
[1, 0],
[0, 1],
[-1, 0],
[0, -1], # j,k,l,m
# [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
],
device=self.device).float() * g # offsets
for i in range(self.nl):
anchors, shape = self.anchors[i], p[i].shape
gain[2:6] = torch.tensor(shape)[[3, 2, 3, 2]] # xyxy gain
# Match targets to anchors
t = targets * gain # shape(3,n,7)
if nt:
# Matches
r = t[..., 4:6] / anchors[:, None] # wh ratio
j = torch.max(r, 1 / r).max(2)[0] < self.hyp['anchor_t'] # compare
# j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
t = t[j] # filter
# Offsets
gxy = t[:, 2:4] # grid xy
gxi = gain[[2, 3]] - gxy # inverse
j, k = ((gxy % 1 < g) & (gxy > 1)).T
l, m = ((gxi % 1 < g) & (gxi > 1)).T
j = torch.stack((torch.ones_like(j), j, k, l, m))
t = t.repeat((5, 1, 1))[j]
offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
else:
t = targets[0]
offsets = 0
# Define
bc, gxy, gwh, a = t.chunk(4, 1) # (image, class), grid xy, grid wh, anchors
a, (b, c) = a.long().view(-1), bc.long().T # anchors, image, class
gij = (gxy - offsets).long()
gi, gj = gij.T # grid indices
# Append
indices.append((b, a, gj.clamp_(0, shape[2] - 1), gi.clamp_(0, shape[3] - 1))) # image, anchor, grid
tbox.append(torch.cat((gxy - gij, gwh), 1)) # box
anch.append(anchors[a]) # anchors
tcls.append(c) # class
return tcls, tbox, indices, anch
| 9,919 | Python | .py | 192 | 40.567708 | 119 | 0.543624 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,528 | activations.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/activations.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Activation functions
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class SiLU(nn.Module):
# SiLU activation https://arxiv.org/pdf/1606.08415.pdf
@staticmethod
def forward(x):
return x * torch.sigmoid(x)
class Hardswish(nn.Module):
# Hard-SiLU activation
@staticmethod
def forward(x):
# return x * F.hardsigmoid(x) # for TorchScript and CoreML
return x * F.hardtanh(x + 3, 0.0, 6.0) / 6.0 # for TorchScript, CoreML and ONNX
class Mish(nn.Module):
# Mish activation https://github.com/digantamisra98/Mish
@staticmethod
def forward(x):
return x * F.softplus(x).tanh()
class MemoryEfficientMish(nn.Module):
# Mish activation memory-efficient
class F(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
ctx.save_for_backward(x)
return x.mul(torch.tanh(F.softplus(x))) # x * tanh(ln(1 + exp(x)))
@staticmethod
def backward(ctx, grad_output):
x = ctx.saved_tensors[0]
sx = torch.sigmoid(x)
fx = F.softplus(x).tanh()
return grad_output * (fx + x * sx * (1 - fx * fx))
def forward(self, x):
return self.F.apply(x)
class FReLU(nn.Module):
# FReLU activation https://arxiv.org/abs/2007.11824
def __init__(self, c1, k=3): # ch_in, kernel
super().__init__()
self.conv = nn.Conv2d(c1, c1, k, 1, 1, groups=c1, bias=False)
self.bn = nn.BatchNorm2d(c1)
def forward(self, x):
return torch.max(x, self.bn(self.conv(x)))
class AconC(nn.Module):
r""" ACON activation (activate or not)
AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"""
def __init__(self, c1):
super().__init__()
self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
self.beta = nn.Parameter(torch.ones(1, c1, 1, 1))
def forward(self, x):
dpx = (self.p1 - self.p2) * x
return dpx * torch.sigmoid(self.beta * dpx) + self.p2 * x
class MetaAconC(nn.Module):
r""" ACON activation (activate or not)
MetaAconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is generated by a small network
according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"""
def __init__(self, c1, k=1, s=1, r=16): # ch_in, kernel, stride, r
super().__init__()
c2 = max(r, c1 // r)
self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
self.fc1 = nn.Conv2d(c1, c2, k, s, bias=True)
self.fc2 = nn.Conv2d(c2, c1, k, s, bias=True)
# self.bn1 = nn.BatchNorm2d(c2)
# self.bn2 = nn.BatchNorm2d(c1)
def forward(self, x):
y = x.mean(dim=2, keepdims=True).mean(dim=3, keepdims=True)
# batch-size 1 bug/instabilities https://github.com/ultralytics/yolov5/issues/2891
# beta = torch.sigmoid(self.bn2(self.fc2(self.bn1(self.fc1(y))))) # bug/unstable
beta = torch.sigmoid(self.fc2(self.fc1(y))) # bug patch BN layers removed
dpx = (self.p1 - self.p2) * x
return dpx * torch.sigmoid(beta * dpx) + self.p2 * x
| 3,449 | Python | .py | 80 | 36.275 | 106 | 0.615362 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,529 | autobatch.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/autobatch.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Auto-batch utils
"""
from copy import deepcopy
import numpy as np
import torch
from utils.general import LOGGER, colorstr
from utils.torch_utils import profile
def check_train_batch_size(model, imgsz=640, amp=True):
# Check YOLOv5 training batch size
with torch.cuda.amp.autocast(amp):
return autobatch(deepcopy(model).train(), imgsz) # compute optimal batch size
def autobatch(model, imgsz=640, fraction=0.9, batch_size=16):
# Automatically estimate best batch size to use `fraction` of available CUDA memory
# Usage:
# import torch
# from utils.autobatch import autobatch
# model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False)
# print(autobatch(model))
# Check device
prefix = colorstr('AutoBatch: ')
LOGGER.info(f'{prefix}Computing optimal batch size for --imgsz {imgsz}')
device = next(model.parameters()).device # get model device
if device.type == 'cpu':
LOGGER.info(f'{prefix}CUDA not detected, using default CPU batch-size {batch_size}')
return batch_size
# Inspect CUDA memory
gb = 1 << 30 # bytes to GiB (1024 ** 3)
d = str(device).upper() # 'CUDA:0'
properties = torch.cuda.get_device_properties(device) # device properties
t = properties.total_memory / gb # GiB total
r = torch.cuda.memory_reserved(device) / gb # GiB reserved
a = torch.cuda.memory_allocated(device) / gb # GiB allocated
f = t - (r + a) # GiB free
LOGGER.info(f'{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free')
# Profile batch sizes
batch_sizes = [1, 2, 4, 8, 16]
try:
img = [torch.zeros(b, 3, imgsz, imgsz) for b in batch_sizes]
results = profile(img, model, n=3, device=device)
except Exception as e:
LOGGER.warning(f'{prefix}{e}')
# Fit a solution
y = [x[2] for x in results if x] # memory [2]
p = np.polyfit(batch_sizes[:len(y)], y, deg=1) # first degree polynomial fit
b = int((f * fraction - p[1]) / p[0]) # y intercept (optimal batch size)
if None in results: # some sizes failed
i = results.index(None) # first fail index
if b >= batch_sizes[i]: # y intercept above failure point
b = batch_sizes[max(i - 1, 0)] # select prior safe point
fraction = np.polyval(p, b) / t # actual fraction predicted
LOGGER.info(f'{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅')
return b
| 2,584 | Python | .py | 54 | 42.703704 | 120 | 0.656076 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,530 | callbacks.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/callbacks.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Callback utils
"""
class Callbacks:
""""
Handles all registered callbacks for YOLOv5 Hooks
"""
def __init__(self):
# Define the available callbacks
self._callbacks = {
'on_pretrain_routine_start': [],
'on_pretrain_routine_end': [],
'on_train_start': [],
'on_train_epoch_start': [],
'on_train_batch_start': [],
'optimizer_step': [],
'on_before_zero_grad': [],
'on_train_batch_end': [],
'on_train_epoch_end': [],
'on_val_start': [],
'on_val_batch_start': [],
'on_val_image_end': [],
'on_val_batch_end': [],
'on_val_end': [],
'on_fit_epoch_end': [], # fit = train + val
'on_model_save': [],
'on_train_end': [],
'on_params_update': [],
'teardown': [],}
self.stop_training = False # set True to interrupt training
def register_action(self, hook, name='', callback=None):
"""
Register a new action to a callback hook
Args:
hook: The callback hook name to register the action to
name: The name of the action for later reference
callback: The callback to fire
"""
assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
assert callable(callback), f"callback '{callback}' is not callable"
self._callbacks[hook].append({'name': name, 'callback': callback})
def get_registered_actions(self, hook=None):
""""
Returns all the registered actions by callback hook
Args:
hook: The name of the hook to check, defaults to all
"""
return self._callbacks[hook] if hook else self._callbacks
def run(self, hook, *args, **kwargs):
"""
Loop through the registered actions and fire all callbacks
Args:
hook: The name of the hook to check, defaults to all
args: Arguments to receive from YOLOv5
kwargs: Keyword Arguments to receive from YOLOv5
"""
assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
for logger in self._callbacks[hook]:
logger['callback'](*args, **kwargs)
| 2,402 | Python | .py | 60 | 30.183333 | 97 | 0.559417 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,531 | example_request.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/flask_rest_api/example_request.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Perform test request
"""
import pprint
import requests
DETECTION_URL = "http://localhost:5000/v1/object-detection/yolov5s"
IMAGE = "zidane.jpg"
# Read image
with open(IMAGE, "rb") as f:
image_data = f.read()
response = requests.post(DETECTION_URL, files={"image": image_data}).json()
pprint.pprint(response)
| 368 | Python | .py | 13 | 26.538462 | 75 | 0.747851 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,532 | restapi.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/flask_rest_api/restapi.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Run a Flask REST API exposing one or more YOLOv5s models
"""
import argparse
import io
import torch
from flask import Flask, request
from PIL import Image
app = Flask(__name__)
models = {}
DETECTION_URL = "/v1/object-detection/<model>"
@app.route(DETECTION_URL, methods=["POST"])
def predict(model):
if request.method != "POST":
return
if request.files.get("image"):
# Method 1
# with request.files["image"] as f:
# im = Image.open(io.BytesIO(f.read()))
# Method 2
im_file = request.files["image"]
im_bytes = im_file.read()
im = Image.open(io.BytesIO(im_bytes))
if model in models:
results = models[model](im, size=640) # reduce size=320 for faster inference
return results.pandas().xyxy[0].to_json(orient="records")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Flask API exposing YOLOv5 model")
parser.add_argument("--port", default=5000, type=int, help="port number")
parser.add_argument('--model', nargs='+', default=['yolov5s'], help='model(s) to run, i.e. --model yolov5n yolov5s')
opt = parser.parse_args()
for m in opt.model:
models[m] = torch.hub.load("ultralytics/yolov5", m, force_reload=True, skip_validation=True)
app.run(host="0.0.0.0", port=opt.port) # debug=True causes Restarting with stat
| 1,439 | Python | .py | 35 | 35.857143 | 120 | 0.6578 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,533 | __init__.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/__init__.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Logging utils
"""
import os
import warnings
from pathlib import Path
import pkg_resources as pkg
import torch
from torch.utils.tensorboard import SummaryWriter
from utils.general import colorstr, cv2
from utils.loggers.clearml.clearml_utils import ClearmlLogger
from utils.loggers.wandb.wandb_utils import WandbLogger
from utils.plots import plot_images, plot_results
from utils.torch_utils import de_parallel
LOGGERS = ('csv', 'tb', 'wandb', 'clearml') # *.csv, TensorBoard, Weights & Biases, ClearML
RANK = int(os.getenv('RANK', -1))
try:
import wandb
assert hasattr(wandb, '__version__') # verify package import not local dir
if pkg.parse_version(wandb.__version__) >= pkg.parse_version('0.12.2') and RANK in {0, -1}:
try:
wandb_login_success = wandb.login(timeout=30)
except wandb.errors.UsageError: # known non-TTY terminal issue
wandb_login_success = False
if not wandb_login_success:
wandb = None
except (ImportError, AssertionError):
wandb = None
try:
import clearml
assert hasattr(clearml, '__version__') # verify package import not local dir
except (ImportError, AssertionError):
clearml = None
class Loggers():
# YOLOv5 Loggers class
def __init__(self, save_dir=None, weights=None, opt=None, hyp=None, logger=None, include=LOGGERS):
self.save_dir = save_dir
self.weights = weights
self.opt = opt
self.hyp = hyp
self.logger = logger # for printing results to console
self.include = include
self.keys = [
'train/box_loss',
'train/obj_loss',
'train/cls_loss', # train loss
'metrics/precision',
'metrics/recall',
'metrics/mAP_0.5',
'metrics/mAP_0.5:0.95', # metrics
'val/box_loss',
'val/obj_loss',
'val/cls_loss', # val loss
'x/lr0',
'x/lr1',
'x/lr2'] # params
self.best_keys = ['best/epoch', 'best/precision', 'best/recall', 'best/mAP_0.5', 'best/mAP_0.5:0.95']
for k in LOGGERS:
setattr(self, k, None) # init empty logger dictionary
self.csv = True # always log to csv
# Messages
if not wandb:
prefix = colorstr('Weights & Biases: ')
s = f"{prefix}run 'pip install wandb' to automatically track and visualize YOLOv5 🚀 runs in Weights & Biases"
self.logger.info(s)
if not clearml:
prefix = colorstr('ClearML: ')
s = f"{prefix}run 'pip install clearml' to automatically track, visualize and remotely train YOLOv5 🚀 in ClearML"
self.logger.info(s)
# TensorBoard
s = self.save_dir
if 'tb' in self.include and not self.opt.evolve:
prefix = colorstr('TensorBoard: ')
self.logger.info(f"{prefix}Start with 'tensorboard --logdir {s.parent}', view at http://localhost:6006/")
self.tb = SummaryWriter(str(s))
# W&B
if wandb and 'wandb' in self.include:
wandb_artifact_resume = isinstance(self.opt.resume, str) and self.opt.resume.startswith('wandb-artifact://')
run_id = torch.load(self.weights).get('wandb_id') if self.opt.resume and not wandb_artifact_resume else None
self.opt.hyp = self.hyp # add hyperparameters
self.wandb = WandbLogger(self.opt, run_id)
# temp warn. because nested artifacts not supported after 0.12.10
if pkg.parse_version(wandb.__version__) >= pkg.parse_version('0.12.11'):
s = "YOLOv5 temporarily requires wandb version 0.12.10 or below. Some features may not work as expected."
self.logger.warning(s)
else:
self.wandb = None
# ClearML
if clearml and 'clearml' in self.include:
self.clearml = ClearmlLogger(self.opt, self.hyp)
else:
self.clearml = None
def on_train_start(self):
# Callback runs on train start
pass
def on_pretrain_routine_end(self):
# Callback runs on pre-train routine end
paths = self.save_dir.glob('*labels*.jpg') # training labels
if self.wandb:
self.wandb.log({"Labels": [wandb.Image(str(x), caption=x.name) for x in paths]})
if self.clearml:
pass # ClearML saves these images automatically using hooks
def on_train_batch_end(self, ni, model, imgs, targets, paths, plots):
# Callback runs on train batch end
# ni: number integrated batches (since train start)
if plots:
if ni == 0 and not self.opt.sync_bn and self.tb:
log_tensorboard_graph(self.tb, model, imgsz=list(imgs.shape[2:4]))
if ni < 3:
f = self.save_dir / f'train_batch{ni}.jpg' # filename
plot_images(imgs, targets, paths, f)
if (self.wandb or self.clearml) and ni == 10:
files = sorted(self.save_dir.glob('train*.jpg'))
if self.wandb:
self.wandb.log({'Mosaics': [wandb.Image(str(f), caption=f.name) for f in files if f.exists()]})
if self.clearml:
self.clearml.log_debug_samples(files, title='Mosaics')
def on_train_epoch_end(self, epoch):
# Callback runs on train epoch end
if self.wandb:
self.wandb.current_epoch = epoch + 1
def on_val_image_end(self, pred, predn, path, names, im):
# Callback runs on val image end
if self.wandb:
self.wandb.val_one_image(pred, predn, path, names, im)
if self.clearml:
self.clearml.log_image_with_boxes(path, pred, names, im)
def on_val_end(self):
# Callback runs on val end
if self.wandb or self.clearml:
files = sorted(self.save_dir.glob('val*.jpg'))
if self.wandb:
self.wandb.log({"Validation": [wandb.Image(str(f), caption=f.name) for f in files]})
if self.clearml:
self.clearml.log_debug_samples(files, title='Validation')
def on_fit_epoch_end(self, vals, epoch, best_fitness, fi):
# Callback runs at the end of each fit (train+val) epoch
x = dict(zip(self.keys, vals))
if self.csv:
file = self.save_dir / 'results.csv'
n = len(x) + 1 # number of cols
s = '' if file.exists() else (('%20s,' * n % tuple(['epoch'] + self.keys)).rstrip(',') + '\n') # add header
with open(file, 'a') as f:
f.write(s + ('%20.5g,' * n % tuple([epoch] + vals)).rstrip(',') + '\n')
if self.tb:
for k, v in x.items():
self.tb.add_scalar(k, v, epoch)
elif self.clearml: # log to ClearML if TensorBoard not used
for k, v in x.items():
title, series = k.split('/')
self.clearml.task.get_logger().report_scalar(title, series, v, epoch)
if self.wandb:
if best_fitness == fi:
best_results = [epoch] + vals[3:7]
for i, name in enumerate(self.best_keys):
self.wandb.wandb_run.summary[name] = best_results[i] # log best results in the summary
self.wandb.log(x)
self.wandb.end_epoch(best_result=best_fitness == fi)
if self.clearml:
self.clearml.current_epoch_logged_images = set() # reset epoch image limit
self.clearml.current_epoch += 1
def on_model_save(self, last, epoch, final_epoch, best_fitness, fi):
# Callback runs on model save event
if self.wandb:
if ((epoch + 1) % self.opt.save_period == 0 and not final_epoch) and self.opt.save_period != -1:
self.wandb.log_model(last.parent, self.opt, epoch, fi, best_model=best_fitness == fi)
if self.clearml:
if ((epoch + 1) % self.opt.save_period == 0 and not final_epoch) and self.opt.save_period != -1:
self.clearml.task.update_output_model(model_path=str(last),
model_name='Latest Model',
auto_delete_file=False)
def on_train_end(self, last, best, plots, epoch, results):
# Callback runs on training end
if plots:
plot_results(file=self.save_dir / 'results.csv') # save results.png
files = ['results.png', 'confusion_matrix.png', *(f'{x}_curve.png' for x in ('F1', 'PR', 'P', 'R'))]
files = [(self.save_dir / f) for f in files if (self.save_dir / f).exists()] # filter
self.logger.info(f"Results saved to {colorstr('bold', self.save_dir)}")
if self.tb and not self.clearml: # These images are already captured by ClearML by now, we don't want doubles
for f in files:
self.tb.add_image(f.stem, cv2.imread(str(f))[..., ::-1], epoch, dataformats='HWC')
if self.wandb:
self.wandb.log(dict(zip(self.keys[3:10], results)))
self.wandb.log({"Results": [wandb.Image(str(f), caption=f.name) for f in files]})
# Calling wandb.log. TODO: Refactor this into WandbLogger.log_model
if not self.opt.evolve:
wandb.log_artifact(str(best if best.exists() else last),
type='model',
name=f'run_{self.wandb.wandb_run.id}_model',
aliases=['latest', 'best', 'stripped'])
self.wandb.finish_run()
if self.clearml:
# Save the best model here
if not self.opt.evolve:
self.clearml.task.update_output_model(model_path=str(best if best.exists() else last),
name='Best Model')
def on_params_update(self, params):
# Update hyperparams or configs of the experiment
# params: A dict containing {param: value} pairs
if self.wandb:
self.wandb.wandb_run.config.update(params, allow_val_change=True)
class GenericLogger:
"""
YOLOv5 General purpose logger for non-task specific logging
Usage: from utils.loggers import GenericLogger; logger = GenericLogger(...)
Arguments
opt: Run arguments
console_logger: Console logger
include: loggers to include
"""
def __init__(self, opt, console_logger, include=('tb', 'wandb')):
# init default loggers
self.save_dir = opt.save_dir
self.include = include
self.console_logger = console_logger
if 'tb' in self.include:
prefix = colorstr('TensorBoard: ')
self.console_logger.info(
f"{prefix}Start with 'tensorboard --logdir {self.save_dir.parent}', view at http://localhost:6006/")
self.tb = SummaryWriter(str(self.save_dir))
if wandb and 'wandb' in self.include:
self.wandb = wandb.init(project="YOLOv5-Classifier" if opt.project == "runs/train" else opt.project,
name=None if opt.name == "exp" else opt.name,
config=opt)
else:
self.wandb = None
def log_metrics(self, metrics_dict, epoch):
# Log metrics dictionary to all loggers
if self.tb:
for k, v in metrics_dict.items():
self.tb.add_scalar(k, v, epoch)
if self.wandb:
self.wandb.log(metrics_dict, step=epoch)
def log_images(self, files, name='Images', epoch=0):
# Log images to all loggers
files = [Path(f) for f in (files if isinstance(files, (tuple, list)) else [files])] # to Path
files = [f for f in files if f.exists()] # filter by exists
if self.tb:
for f in files:
self.tb.add_image(f.stem, cv2.imread(str(f))[..., ::-1], epoch, dataformats='HWC')
if self.wandb:
self.wandb.log({name: [wandb.Image(str(f), caption=f.name) for f in files]}, step=epoch)
def log_graph(self, model, imgsz=(640, 640)):
# Log model graph to all loggers
if self.tb:
log_tensorboard_graph(self.tb, model, imgsz)
def log_model(self, model_path, epoch=0, metadata={}):
# Log model to all loggers
if self.wandb:
art = wandb.Artifact(name=f"run_{wandb.run.id}_model", type="model", metadata=metadata)
art.add_file(str(model_path))
wandb.log_artifact(art)
def log_tensorboard_graph(tb, model, imgsz=(640, 640)):
# Log model graph to TensorBoard
try:
p = next(model.parameters()) # for device, type
imgsz = (imgsz, imgsz) if isinstance(imgsz, int) else imgsz # expand
im = torch.zeros((1, 3, *imgsz)).to(p.device).type_as(p) # input image
with warnings.catch_warnings():
warnings.simplefilter('ignore') # suppress jit trace warning
tb.add_graph(torch.jit.trace(de_parallel(model), im, strict=False), [])
except Exception:
print('WARNING: TensorBoard graph visualization failure')
| 13,262 | Python | .py | 264 | 39.102273 | 128 | 0.588081 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,534 | log_dataset.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/wandb/log_dataset.py | import argparse
from wandb_utils import WandbLogger
from utils.general import LOGGER
WANDB_ARTIFACT_PREFIX = 'wandb-artifact://'
def create_dataset_artifact(opt):
logger = WandbLogger(opt, None, job_type='Dataset Creation') # TODO: return value unused
if not logger.wandb:
LOGGER.info("install wandb using `pip install wandb` to log the dataset")
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--data', type=str, default='data/coco128.yaml', help='data.yaml path')
parser.add_argument('--single-cls', action='store_true', help='train as single-class dataset')
parser.add_argument('--project', type=str, default='YOLOv5', help='name of W&B Project')
parser.add_argument('--entity', default=None, help='W&B entity')
parser.add_argument('--name', type=str, default='log dataset', help='name of W&B run')
opt = parser.parse_args()
opt.resume = False # Explicitly disallow resume check for dataset upload job
create_dataset_artifact(opt)
| 1,032 | Python | .py | 18 | 52.944444 | 98 | 0.715423 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,535 | wandb_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/wandb/wandb_utils.py | """Utilities and tools for tracking runs with Weights & Biases."""
import logging
import os
import sys
from contextlib import contextmanager
from pathlib import Path
from typing import Dict
import yaml
from tqdm import tqdm
FILE = Path(__file__).resolve()
ROOT = FILE.parents[3] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
from utils.dataloaders import LoadImagesAndLabels, img2label_paths
from utils.general import LOGGER, check_dataset, check_file
try:
import wandb
assert hasattr(wandb, '__version__') # verify package import not local dir
except (ImportError, AssertionError):
wandb = None
RANK = int(os.getenv('RANK', -1))
WANDB_ARTIFACT_PREFIX = 'wandb-artifact://'
def remove_prefix(from_string, prefix=WANDB_ARTIFACT_PREFIX):
return from_string[len(prefix):]
def check_wandb_config_file(data_config_file):
wandb_config = '_wandb.'.join(data_config_file.rsplit('.', 1)) # updated data.yaml path
if Path(wandb_config).is_file():
return wandb_config
return data_config_file
def check_wandb_dataset(data_file):
is_trainset_wandb_artifact = False
is_valset_wandb_artifact = False
if isinstance(data_file, dict):
# In that case another dataset manager has already processed it and we don't have to
return data_file
if check_file(data_file) and data_file.endswith('.yaml'):
with open(data_file, errors='ignore') as f:
data_dict = yaml.safe_load(f)
is_trainset_wandb_artifact = isinstance(data_dict['train'],
str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX)
is_valset_wandb_artifact = isinstance(data_dict['val'],
str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX)
if is_trainset_wandb_artifact or is_valset_wandb_artifact:
return data_dict
else:
return check_dataset(data_file)
def get_run_info(run_path):
run_path = Path(remove_prefix(run_path, WANDB_ARTIFACT_PREFIX))
run_id = run_path.stem
project = run_path.parent.stem
entity = run_path.parent.parent.stem
model_artifact_name = 'run_' + run_id + '_model'
return entity, project, run_id, model_artifact_name
def check_wandb_resume(opt):
process_wandb_config_ddp_mode(opt) if RANK not in [-1, 0] else None
if isinstance(opt.resume, str):
if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
if RANK not in [-1, 0]: # For resuming DDP runs
entity, project, run_id, model_artifact_name = get_run_info(opt.resume)
api = wandb.Api()
artifact = api.artifact(entity + '/' + project + '/' + model_artifact_name + ':latest')
modeldir = artifact.download()
opt.weights = str(Path(modeldir) / "last.pt")
return True
return None
def process_wandb_config_ddp_mode(opt):
with open(check_file(opt.data), errors='ignore') as f:
data_dict = yaml.safe_load(f) # data dict
train_dir, val_dir = None, None
if isinstance(data_dict['train'], str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX):
api = wandb.Api()
train_artifact = api.artifact(remove_prefix(data_dict['train']) + ':' + opt.artifact_alias)
train_dir = train_artifact.download()
train_path = Path(train_dir) / 'data/images/'
data_dict['train'] = str(train_path)
if isinstance(data_dict['val'], str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX):
api = wandb.Api()
val_artifact = api.artifact(remove_prefix(data_dict['val']) + ':' + opt.artifact_alias)
val_dir = val_artifact.download()
val_path = Path(val_dir) / 'data/images/'
data_dict['val'] = str(val_path)
if train_dir or val_dir:
ddp_data_path = str(Path(val_dir) / 'wandb_local_data.yaml')
with open(ddp_data_path, 'w') as f:
yaml.safe_dump(data_dict, f)
opt.data = ddp_data_path
class WandbLogger():
"""Log training runs, datasets, models, and predictions to Weights & Biases.
This logger sends information to W&B at wandb.ai. By default, this information
includes hyperparameters, system configuration and metrics, model metrics,
and basic data metrics and analyses.
By providing additional command line arguments to train.py, datasets,
models and predictions can also be logged.
For more on how this logger is used, see the Weights & Biases documentation:
https://docs.wandb.com/guides/integrations/yolov5
"""
def __init__(self, opt, run_id=None, job_type='Training'):
"""
- Initialize WandbLogger instance
- Upload dataset if opt.upload_dataset is True
- Setup training processes if job_type is 'Training'
arguments:
opt (namespace) -- Commandline arguments for this run
run_id (str) -- Run ID of W&B run to be resumed
job_type (str) -- To set the job_type for this run
"""
# Pre-training routine --
self.job_type = job_type
self.wandb, self.wandb_run = wandb, None if not wandb else wandb.run
self.val_artifact, self.train_artifact = None, None
self.train_artifact_path, self.val_artifact_path = None, None
self.result_artifact = None
self.val_table, self.result_table = None, None
self.bbox_media_panel_images = []
self.val_table_path_map = None
self.max_imgs_to_log = 16
self.wandb_artifact_data_dict = None
self.data_dict = None
# It's more elegant to stick to 1 wandb.init call,
# but useful config data is overwritten in the WandbLogger's wandb.init call
if isinstance(opt.resume, str): # checks resume from artifact
if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
entity, project, run_id, model_artifact_name = get_run_info(opt.resume)
model_artifact_name = WANDB_ARTIFACT_PREFIX + model_artifact_name
assert wandb, 'install wandb to resume wandb runs'
# Resume wandb-artifact:// runs here| workaround for not overwriting wandb.config
self.wandb_run = wandb.init(id=run_id,
project=project,
entity=entity,
resume='allow',
allow_val_change=True)
opt.resume = model_artifact_name
elif self.wandb:
self.wandb_run = wandb.init(config=opt,
resume="allow",
project='YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem,
entity=opt.entity,
name=opt.name if opt.name != 'exp' else None,
job_type=job_type,
id=run_id,
allow_val_change=True) if not wandb.run else wandb.run
if self.wandb_run:
if self.job_type == 'Training':
if opt.upload_dataset:
if not opt.resume:
self.wandb_artifact_data_dict = self.check_and_upload_dataset(opt)
if isinstance(opt.data, dict):
# This means another dataset manager has already processed the dataset info (e.g. ClearML)
# and they will have stored the already processed dict in opt.data
self.data_dict = opt.data
elif opt.resume:
# resume from artifact
if isinstance(opt.resume, str) and opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
self.data_dict = dict(self.wandb_run.config.data_dict)
else: # local resume
self.data_dict = check_wandb_dataset(opt.data)
else:
self.data_dict = check_wandb_dataset(opt.data)
self.wandb_artifact_data_dict = self.wandb_artifact_data_dict or self.data_dict
# write data_dict to config. useful for resuming from artifacts. Do this only when not resuming.
self.wandb_run.config.update({'data_dict': self.wandb_artifact_data_dict}, allow_val_change=True)
self.setup_training(opt)
if self.job_type == 'Dataset Creation':
self.wandb_run.config.update({"upload_dataset": True})
self.data_dict = self.check_and_upload_dataset(opt)
def check_and_upload_dataset(self, opt):
"""
Check if the dataset format is compatible and upload it as W&B artifact
arguments:
opt (namespace)-- Commandline arguments for current run
returns:
Updated dataset info dictionary where local dataset paths are replaced by WAND_ARFACT_PREFIX links.
"""
assert wandb, 'Install wandb to upload dataset'
config_path = self.log_dataset_artifact(opt.data, opt.single_cls,
'YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem)
with open(config_path, errors='ignore') as f:
wandb_data_dict = yaml.safe_load(f)
return wandb_data_dict
def setup_training(self, opt):
"""
Setup the necessary processes for training YOLO models:
- Attempt to download model checkpoint and dataset artifacts if opt.resume stats with WANDB_ARTIFACT_PREFIX
- Update data_dict, to contain info of previous run if resumed and the paths of dataset artifact if downloaded
- Setup log_dict, initialize bbox_interval
arguments:
opt (namespace) -- commandline arguments for this run
"""
self.log_dict, self.current_epoch = {}, 0
self.bbox_interval = opt.bbox_interval
if isinstance(opt.resume, str):
modeldir, _ = self.download_model_artifact(opt)
if modeldir:
self.weights = Path(modeldir) / "last.pt"
config = self.wandb_run.config
opt.weights, opt.save_period, opt.batch_size, opt.bbox_interval, opt.epochs, opt.hyp, opt.imgsz = str(
self.weights), config.save_period, config.batch_size, config.bbox_interval, config.epochs,\
config.hyp, config.imgsz
data_dict = self.data_dict
if self.val_artifact is None: # If --upload_dataset is set, use the existing artifact, don't download
self.train_artifact_path, self.train_artifact = self.download_dataset_artifact(
data_dict.get('train'), opt.artifact_alias)
self.val_artifact_path, self.val_artifact = self.download_dataset_artifact(
data_dict.get('val'), opt.artifact_alias)
if self.train_artifact_path is not None:
train_path = Path(self.train_artifact_path) / 'data/images/'
data_dict['train'] = str(train_path)
if self.val_artifact_path is not None:
val_path = Path(self.val_artifact_path) / 'data/images/'
data_dict['val'] = str(val_path)
if self.val_artifact is not None:
self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation")
columns = ["epoch", "id", "ground truth", "prediction"]
columns.extend(self.data_dict['names'])
self.result_table = wandb.Table(columns)
self.val_table = self.val_artifact.get("val")
if self.val_table_path_map is None:
self.map_val_table_path()
if opt.bbox_interval == -1:
self.bbox_interval = opt.bbox_interval = (opt.epochs // 10) if opt.epochs > 10 else 1
if opt.evolve or opt.noplots:
self.bbox_interval = opt.bbox_interval = opt.epochs + 1 # disable bbox_interval
train_from_artifact = self.train_artifact_path is not None and self.val_artifact_path is not None
# Update the the data_dict to point to local artifacts dir
if train_from_artifact:
self.data_dict = data_dict
def download_dataset_artifact(self, path, alias):
"""
download the model checkpoint artifact if the path starts with WANDB_ARTIFACT_PREFIX
arguments:
path -- path of the dataset to be used for training
alias (str)-- alias of the artifact to be download/used for training
returns:
(str, wandb.Artifact) -- path of the downladed dataset and it's corresponding artifact object if dataset
is found otherwise returns (None, None)
"""
if isinstance(path, str) and path.startswith(WANDB_ARTIFACT_PREFIX):
artifact_path = Path(remove_prefix(path, WANDB_ARTIFACT_PREFIX) + ":" + alias)
dataset_artifact = wandb.use_artifact(artifact_path.as_posix().replace("\\", "/"))
assert dataset_artifact is not None, "'Error: W&B dataset artifact doesn\'t exist'"
datadir = dataset_artifact.download()
return datadir, dataset_artifact
return None, None
def download_model_artifact(self, opt):
"""
download the model checkpoint artifact if the resume path starts with WANDB_ARTIFACT_PREFIX
arguments:
opt (namespace) -- Commandline arguments for this run
"""
if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
model_artifact = wandb.use_artifact(remove_prefix(opt.resume, WANDB_ARTIFACT_PREFIX) + ":latest")
assert model_artifact is not None, 'Error: W&B model artifact doesn\'t exist'
modeldir = model_artifact.download()
# epochs_trained = model_artifact.metadata.get('epochs_trained')
total_epochs = model_artifact.metadata.get('total_epochs')
is_finished = total_epochs is None
assert not is_finished, 'training is finished, can only resume incomplete runs.'
return modeldir, model_artifact
return None, None
def log_model(self, path, opt, epoch, fitness_score, best_model=False):
"""
Log the model checkpoint as W&B artifact
arguments:
path (Path) -- Path of directory containing the checkpoints
opt (namespace) -- Command line arguments for this run
epoch (int) -- Current epoch number
fitness_score (float) -- fitness score for current epoch
best_model (boolean) -- Boolean representing if the current checkpoint is the best yet.
"""
model_artifact = wandb.Artifact('run_' + wandb.run.id + '_model',
type='model',
metadata={
'original_url': str(path),
'epochs_trained': epoch + 1,
'save period': opt.save_period,
'project': opt.project,
'total_epochs': opt.epochs,
'fitness_score': fitness_score})
model_artifact.add_file(str(path / 'last.pt'), name='last.pt')
wandb.log_artifact(model_artifact,
aliases=['latest', 'last', 'epoch ' + str(self.current_epoch), 'best' if best_model else ''])
LOGGER.info(f"Saving model artifact on epoch {epoch + 1}")
def log_dataset_artifact(self, data_file, single_cls, project, overwrite_config=False):
"""
Log the dataset as W&B artifact and return the new data file with W&B links
arguments:
data_file (str) -- the .yaml file with information about the dataset like - path, classes etc.
single_class (boolean) -- train multi-class data as single-class
project (str) -- project name. Used to construct the artifact path
overwrite_config (boolean) -- overwrites the data.yaml file if set to true otherwise creates a new
file with _wandb postfix. Eg -> data_wandb.yaml
returns:
the new .yaml file with artifact links. it can be used to start training directly from artifacts
"""
upload_dataset = self.wandb_run.config.upload_dataset
log_val_only = isinstance(upload_dataset, str) and upload_dataset == 'val'
self.data_dict = check_dataset(data_file) # parse and check
data = dict(self.data_dict)
nc, names = (1, ['item']) if single_cls else (int(data['nc']), data['names'])
names = {k: v for k, v in enumerate(names)} # to index dictionary
# log train set
if not log_val_only:
self.train_artifact = self.create_dataset_table(LoadImagesAndLabels(data['train'], rect=True, batch_size=1),
names,
name='train') if data.get('train') else None
if data.get('train'):
data['train'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'train')
self.val_artifact = self.create_dataset_table(
LoadImagesAndLabels(data['val'], rect=True, batch_size=1), names, name='val') if data.get('val') else None
if data.get('val'):
data['val'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'val')
path = Path(data_file)
# create a _wandb.yaml file with artifacts links if both train and test set are logged
if not log_val_only:
path = (path.stem if overwrite_config else path.stem + '_wandb') + '.yaml' # updated data.yaml path
path = ROOT / 'data' / path
data.pop('download', None)
data.pop('path', None)
with open(path, 'w') as f:
yaml.safe_dump(data, f)
LOGGER.info(f"Created dataset config file {path}")
if self.job_type == 'Training': # builds correct artifact pipeline graph
if not log_val_only:
self.wandb_run.log_artifact(
self.train_artifact) # calling use_artifact downloads the dataset. NOT NEEDED!
self.wandb_run.use_artifact(self.val_artifact)
self.val_artifact.wait()
self.val_table = self.val_artifact.get('val')
self.map_val_table_path()
else:
self.wandb_run.log_artifact(self.train_artifact)
self.wandb_run.log_artifact(self.val_artifact)
return path
def map_val_table_path(self):
"""
Map the validation dataset Table like name of file -> it's id in the W&B Table.
Useful for - referencing artifacts for evaluation.
"""
self.val_table_path_map = {}
LOGGER.info("Mapping dataset")
for i, data in enumerate(tqdm(self.val_table.data)):
self.val_table_path_map[data[3]] = data[0]
def create_dataset_table(self, dataset: LoadImagesAndLabels, class_to_id: Dict[int, str], name: str = 'dataset'):
"""
Create and return W&B artifact containing W&B Table of the dataset.
arguments:
dataset -- instance of LoadImagesAndLabels class used to iterate over the data to build Table
class_to_id -- hash map that maps class ids to labels
name -- name of the artifact
returns:
dataset artifact to be logged or used
"""
# TODO: Explore multiprocessing to slpit this loop parallely| This is essential for speeding up the the logging
artifact = wandb.Artifact(name=name, type="dataset")
img_files = tqdm([dataset.path]) if isinstance(dataset.path, str) and Path(dataset.path).is_dir() else None
img_files = tqdm(dataset.im_files) if not img_files else img_files
for img_file in img_files:
if Path(img_file).is_dir():
artifact.add_dir(img_file, name='data/images')
labels_path = 'labels'.join(dataset.path.rsplit('images', 1))
artifact.add_dir(labels_path, name='data/labels')
else:
artifact.add_file(img_file, name='data/images/' + Path(img_file).name)
label_file = Path(img2label_paths([img_file])[0])
artifact.add_file(str(label_file), name='data/labels/' +
label_file.name) if label_file.exists() else None
table = wandb.Table(columns=["id", "train_image", "Classes", "name"])
class_set = wandb.Classes([{'id': id, 'name': name} for id, name in class_to_id.items()])
for si, (img, labels, paths, shapes) in enumerate(tqdm(dataset)):
box_data, img_classes = [], {}
for cls, *xywh in labels[:, 1:].tolist():
cls = int(cls)
box_data.append({
"position": {
"middle": [xywh[0], xywh[1]],
"width": xywh[2],
"height": xywh[3]},
"class_id": cls,
"box_caption": "%s" % (class_to_id[cls])})
img_classes[cls] = class_to_id[cls]
boxes = {"ground_truth": {"box_data": box_data, "class_labels": class_to_id}} # inference-space
table.add_data(si, wandb.Image(paths, classes=class_set, boxes=boxes), list(img_classes.values()),
Path(paths).name)
artifact.add(table, name)
return artifact
def log_training_progress(self, predn, path, names):
"""
Build evaluation Table. Uses reference from validation dataset table.
arguments:
predn (list): list of predictions in the native space in the format - [xmin, ymin, xmax, ymax, confidence, class]
path (str): local path of the current evaluation image
names (dict(int, str)): hash map that maps class ids to labels
"""
class_set = wandb.Classes([{'id': id, 'name': name} for id, name in names.items()])
box_data = []
avg_conf_per_class = [0] * len(self.data_dict['names'])
pred_class_count = {}
for *xyxy, conf, cls in predn.tolist():
if conf >= 0.25:
cls = int(cls)
box_data.append({
"position": {
"minX": xyxy[0],
"minY": xyxy[1],
"maxX": xyxy[2],
"maxY": xyxy[3]},
"class_id": cls,
"box_caption": f"{names[cls]} {conf:.3f}",
"scores": {
"class_score": conf},
"domain": "pixel"})
avg_conf_per_class[cls] += conf
if cls in pred_class_count:
pred_class_count[cls] += 1
else:
pred_class_count[cls] = 1
for pred_class in pred_class_count.keys():
avg_conf_per_class[pred_class] = avg_conf_per_class[pred_class] / pred_class_count[pred_class]
boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space
id = self.val_table_path_map[Path(path).name]
self.result_table.add_data(self.current_epoch, id, self.val_table.data[id][1],
wandb.Image(self.val_table.data[id][1], boxes=boxes, classes=class_set),
*avg_conf_per_class)
def val_one_image(self, pred, predn, path, names, im):
"""
Log validation data for one image. updates the result Table if validation dataset is uploaded and log bbox media panel
arguments:
pred (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class]
predn (list): list of predictions in the native space - [xmin, ymin, xmax, ymax, confidence, class]
path (str): local path of the current evaluation image
"""
if self.val_table and self.result_table: # Log Table if Val dataset is uploaded as artifact
self.log_training_progress(predn, path, names)
if len(self.bbox_media_panel_images) < self.max_imgs_to_log and self.current_epoch > 0:
if self.current_epoch % self.bbox_interval == 0:
box_data = [{
"position": {
"minX": xyxy[0],
"minY": xyxy[1],
"maxX": xyxy[2],
"maxY": xyxy[3]},
"class_id": int(cls),
"box_caption": f"{names[int(cls)]} {conf:.3f}",
"scores": {
"class_score": conf},
"domain": "pixel"} for *xyxy, conf, cls in pred.tolist()]
boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space
self.bbox_media_panel_images.append(wandb.Image(im, boxes=boxes, caption=path.name))
def log(self, log_dict):
"""
save the metrics to the logging dictionary
arguments:
log_dict (Dict) -- metrics/media to be logged in current step
"""
if self.wandb_run:
for key, value in log_dict.items():
self.log_dict[key] = value
def end_epoch(self, best_result=False):
"""
commit the log_dict, model artifacts and Tables to W&B and flush the log_dict.
arguments:
best_result (boolean): Boolean representing if the result of this evaluation is best or not
"""
if self.wandb_run:
with all_logging_disabled():
if self.bbox_media_panel_images:
self.log_dict["BoundingBoxDebugger"] = self.bbox_media_panel_images
try:
wandb.log(self.log_dict)
except BaseException as e:
LOGGER.info(
f"An error occurred in wandb logger. The training will proceed without interruption. More info\n{e}"
)
self.wandb_run.finish()
self.wandb_run = None
self.log_dict = {}
self.bbox_media_panel_images = []
if self.result_artifact:
self.result_artifact.add(self.result_table, 'result')
wandb.log_artifact(self.result_artifact,
aliases=[
'latest', 'last', 'epoch ' + str(self.current_epoch),
('best' if best_result else '')])
wandb.log({"evaluation": self.result_table})
columns = ["epoch", "id", "ground truth", "prediction"]
columns.extend(self.data_dict['names'])
self.result_table = wandb.Table(columns)
self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation")
def finish_run(self):
"""
Log metrics if any and finish the current W&B run
"""
if self.wandb_run:
if self.log_dict:
with all_logging_disabled():
wandb.log(self.log_dict)
wandb.run.finish()
@contextmanager
def all_logging_disabled(highest_level=logging.CRITICAL):
""" source - https://gist.github.com/simon-weber/7853144
A context manager that will prevent any logging messages triggered during the body from being processed.
:param highest_level: the maximum logging level in use.
This would only need to be changed if a custom level greater than CRITICAL is defined.
"""
previous_level = logging.root.manager.disable
logging.disable(highest_level)
try:
yield
finally:
logging.disable(previous_level)
| 28,034 | Python | .py | 510 | 41.713725 | 126 | 0.586485 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,536 | sweep.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/wandb/sweep.py | import sys
from pathlib import Path
import wandb
FILE = Path(__file__).resolve()
ROOT = FILE.parents[3] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
from train import parse_opt, train
from utils.callbacks import Callbacks
from utils.general import increment_path
from utils.torch_utils import select_device
def sweep():
wandb.init()
# Get hyp dict from sweep agent. Copy because train() modifies parameters which confused wandb.
hyp_dict = vars(wandb.config).get("_items").copy()
# Workaround: get necessary opt args
opt = parse_opt(known=True)
opt.batch_size = hyp_dict.get("batch_size")
opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok or opt.evolve))
opt.epochs = hyp_dict.get("epochs")
opt.nosave = True
opt.data = hyp_dict.get("data")
opt.weights = str(opt.weights)
opt.cfg = str(opt.cfg)
opt.data = str(opt.data)
opt.hyp = str(opt.hyp)
opt.project = str(opt.project)
device = select_device(opt.device, batch_size=opt.batch_size)
# train
train(hyp_dict, opt, device, callbacks=Callbacks())
if __name__ == "__main__":
sweep()
| 1,213 | Python | .py | 32 | 34.125 | 105 | 0.702218 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,537 | hpo.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/clearml/hpo.py | from clearml import Task
# Connecting ClearML with the current process,
# from here on everything is logged automatically
from clearml.automation import HyperParameterOptimizer, UniformParameterRange
from clearml.automation.optuna import OptimizerOptuna
task = Task.init(project_name='Hyper-Parameter Optimization',
task_name='YOLOv5',
task_type=Task.TaskTypes.optimizer,
reuse_last_task_id=False)
# Example use case:
optimizer = HyperParameterOptimizer(
# This is the experiment we want to optimize
base_task_id='<your_template_task_id>',
# here we define the hyper-parameters to optimize
# Notice: The parameter name should exactly match what you see in the UI: <section_name>/<parameter>
# For Example, here we see in the base experiment a section Named: "General"
# under it a parameter named "batch_size", this becomes "General/batch_size"
# If you have `argparse` for example, then arguments will appear under the "Args" section,
# and you should instead pass "Args/batch_size"
hyper_parameters=[
UniformParameterRange('Hyperparameters/lr0', min_value=1e-5, max_value=1e-1),
UniformParameterRange('Hyperparameters/lrf', min_value=0.01, max_value=1.0),
UniformParameterRange('Hyperparameters/momentum', min_value=0.6, max_value=0.98),
UniformParameterRange('Hyperparameters/weight_decay', min_value=0.0, max_value=0.001),
UniformParameterRange('Hyperparameters/warmup_epochs', min_value=0.0, max_value=5.0),
UniformParameterRange('Hyperparameters/warmup_momentum', min_value=0.0, max_value=0.95),
UniformParameterRange('Hyperparameters/warmup_bias_lr', min_value=0.0, max_value=0.2),
UniformParameterRange('Hyperparameters/box', min_value=0.02, max_value=0.2),
UniformParameterRange('Hyperparameters/cls', min_value=0.2, max_value=4.0),
UniformParameterRange('Hyperparameters/cls_pw', min_value=0.5, max_value=2.0),
UniformParameterRange('Hyperparameters/obj', min_value=0.2, max_value=4.0),
UniformParameterRange('Hyperparameters/obj_pw', min_value=0.5, max_value=2.0),
UniformParameterRange('Hyperparameters/iou_t', min_value=0.1, max_value=0.7),
UniformParameterRange('Hyperparameters/anchor_t', min_value=2.0, max_value=8.0),
UniformParameterRange('Hyperparameters/fl_gamma', min_value=0.0, max_value=4.0),
UniformParameterRange('Hyperparameters/hsv_h', min_value=0.0, max_value=0.1),
UniformParameterRange('Hyperparameters/hsv_s', min_value=0.0, max_value=0.9),
UniformParameterRange('Hyperparameters/hsv_v', min_value=0.0, max_value=0.9),
UniformParameterRange('Hyperparameters/degrees', min_value=0.0, max_value=45.0),
UniformParameterRange('Hyperparameters/translate', min_value=0.0, max_value=0.9),
UniformParameterRange('Hyperparameters/scale', min_value=0.0, max_value=0.9),
UniformParameterRange('Hyperparameters/shear', min_value=0.0, max_value=10.0),
UniformParameterRange('Hyperparameters/perspective', min_value=0.0, max_value=0.001),
UniformParameterRange('Hyperparameters/flipud', min_value=0.0, max_value=1.0),
UniformParameterRange('Hyperparameters/fliplr', min_value=0.0, max_value=1.0),
UniformParameterRange('Hyperparameters/mosaic', min_value=0.0, max_value=1.0),
UniformParameterRange('Hyperparameters/mixup', min_value=0.0, max_value=1.0),
UniformParameterRange('Hyperparameters/copy_paste', min_value=0.0, max_value=1.0)],
# this is the objective metric we want to maximize/minimize
objective_metric_title='metrics',
objective_metric_series='mAP_0.5',
# now we decide if we want to maximize it or minimize it (accuracy we maximize)
objective_metric_sign='max',
# let us limit the number of concurrent experiments,
# this in turn will make sure we do dont bombard the scheduler with experiments.
# if we have an auto-scaler connected, this, by proxy, will limit the number of machine
max_number_of_concurrent_tasks=1,
# this is the optimizer class (actually doing the optimization)
# Currently, we can choose from GridSearch, RandomSearch or OptimizerBOHB (Bayesian optimization Hyper-Band)
optimizer_class=OptimizerOptuna,
# If specified only the top K performing Tasks will be kept, the others will be automatically archived
save_top_k_tasks_only=5, # 5,
compute_time_limit=None,
total_max_jobs=20,
min_iteration_per_job=None,
max_iteration_per_job=None,
)
# report every 10 seconds, this is way too often, but we are testing here
optimizer.set_report_period(10)
# You can also use the line below instead to run all the optimizer tasks locally, without using queues or agent
# an_optimizer.start_locally(job_complete_callback=job_complete_callback)
# set the time limit for the optimization process (2 hours)
optimizer.set_time_limit(in_minutes=120.0)
# Start the optimization process in the local environment
optimizer.start_locally()
# wait until process is done (notice we are controlling the optimization process in the background)
optimizer.wait()
# make sure background optimization stopped
optimizer.stop()
print('We are done, good bye')
| 5,266 | Python | .py | 80 | 59.9875 | 112 | 0.740062 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,538 | clearml_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/loggers/clearml/clearml_utils.py | """Main Logger class for ClearML experiment tracking."""
import glob
import re
from pathlib import Path
import numpy as np
import yaml
from utils.plots import Annotator, colors
try:
import clearml
from clearml import Dataset, Task
assert hasattr(clearml, '__version__') # verify package import not local dir
except (ImportError, AssertionError):
clearml = None
def construct_dataset(clearml_info_string):
"""Load in a clearml dataset and fill the internal data_dict with its contents.
"""
dataset_id = clearml_info_string.replace('clearml://', '')
dataset = Dataset.get(dataset_id=dataset_id)
dataset_root_path = Path(dataset.get_local_copy())
# We'll search for the yaml file definition in the dataset
yaml_filenames = list(glob.glob(str(dataset_root_path / "*.yaml")) + glob.glob(str(dataset_root_path / "*.yml")))
if len(yaml_filenames) > 1:
raise ValueError('More than one yaml file was found in the dataset root, cannot determine which one contains '
'the dataset definition this way.')
elif len(yaml_filenames) == 0:
raise ValueError('No yaml definition found in dataset root path, check that there is a correct yaml file '
'inside the dataset root path.')
with open(yaml_filenames[0]) as f:
dataset_definition = yaml.safe_load(f)
assert set(dataset_definition.keys()).issuperset(
{'train', 'test', 'val', 'nc', 'names'}
), "The right keys were not found in the yaml file, make sure it at least has the following keys: ('train', 'test', 'val', 'nc', 'names')"
data_dict = dict()
data_dict['train'] = str(
(dataset_root_path / dataset_definition['train']).resolve()) if dataset_definition['train'] else None
data_dict['test'] = str(
(dataset_root_path / dataset_definition['test']).resolve()) if dataset_definition['test'] else None
data_dict['val'] = str(
(dataset_root_path / dataset_definition['val']).resolve()) if dataset_definition['val'] else None
data_dict['nc'] = dataset_definition['nc']
data_dict['names'] = dataset_definition['names']
return data_dict
class ClearmlLogger:
"""Log training runs, datasets, models, and predictions to ClearML.
This logger sends information to ClearML at app.clear.ml or to your own hosted server. By default,
this information includes hyperparameters, system configuration and metrics, model metrics, code information and
basic data metrics and analyses.
By providing additional command line arguments to train.py, datasets,
models and predictions can also be logged.
"""
def __init__(self, opt, hyp):
"""
- Initialize ClearML Task, this object will capture the experiment
- Upload dataset version to ClearML Data if opt.upload_dataset is True
arguments:
opt (namespace) -- Commandline arguments for this run
hyp (dict) -- Hyperparameters for this run
"""
self.current_epoch = 0
# Keep tracked of amount of logged images to enforce a limit
self.current_epoch_logged_images = set()
# Maximum number of images to log to clearML per epoch
self.max_imgs_to_log_per_epoch = 16
# Get the interval of epochs when bounding box images should be logged
self.bbox_interval = opt.bbox_interval
self.clearml = clearml
self.task = None
self.data_dict = None
if self.clearml:
self.task = Task.init(
project_name='YOLOv5',
task_name='training',
tags=['YOLOv5'],
output_uri=True,
auto_connect_frameworks={'pytorch': False}
# We disconnect pytorch auto-detection, because we added manual model save points in the code
)
# ClearML's hooks will already grab all general parameters
# Only the hyperparameters coming from the yaml config file
# will have to be added manually!
self.task.connect(hyp, name='Hyperparameters')
# Get ClearML Dataset Version if requested
if opt.data.startswith('clearml://'):
# data_dict should have the following keys:
# names, nc (number of classes), test, train, val (all three relative paths to ../datasets)
self.data_dict = construct_dataset(opt.data)
# Set data to data_dict because wandb will crash without this information and opt is the best way
# to give it to them
opt.data = self.data_dict
def log_debug_samples(self, files, title='Debug Samples'):
"""
Log files (images) as debug samples in the ClearML task.
arguments:
files (List(PosixPath)) a list of file paths in PosixPath format
title (str) A title that groups together images with the same values
"""
for f in files:
if f.exists():
it = re.search(r'_batch(\d+)', f.name)
iteration = int(it.groups()[0]) if it else 0
self.task.get_logger().report_image(title=title,
series=f.name.replace(it.group(), ''),
local_path=str(f),
iteration=iteration)
def log_image_with_boxes(self, image_path, boxes, class_names, image, conf_threshold=0.25):
"""
Draw the bounding boxes on a single image and report the result as a ClearML debug sample.
arguments:
image_path (PosixPath) the path the original image file
boxes (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class]
class_names (dict): dict containing mapping of class int to class name
image (Tensor): A torch tensor containing the actual image data
"""
if len(self.current_epoch_logged_images) < self.max_imgs_to_log_per_epoch and self.current_epoch >= 0:
# Log every bbox_interval times and deduplicate for any intermittend extra eval runs
if self.current_epoch % self.bbox_interval == 0 and image_path not in self.current_epoch_logged_images:
im = np.ascontiguousarray(np.moveaxis(image.mul(255).clamp(0, 255).byte().cpu().numpy(), 0, 2))
annotator = Annotator(im=im, pil=True)
for i, (conf, class_nr, box) in enumerate(zip(boxes[:, 4], boxes[:, 5], boxes[:, :4])):
color = colors(i)
class_name = class_names[int(class_nr)]
confidence = round(float(conf) * 100, 2)
label = f"{class_name}: {confidence}%"
if confidence > conf_threshold:
annotator.rectangle(box.cpu().numpy(), outline=color)
annotator.box_label(box.cpu().numpy(), label=label, color=color)
annotated_image = annotator.result()
self.task.get_logger().report_image(title='Bounding Boxes',
series=image_path.name,
iteration=self.current_epoch,
image=annotated_image)
self.current_epoch_logged_images.add(image_path)
| 7,453 | Python | .py | 132 | 44.386364 | 142 | 0.614636 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,539 | dir_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/dir_utils.py | import os
import shutil
# 创建指定文件夹
def create_dir(path):
if os.path.exists(path) is False:
os.makedirs(path)
# 创建指定文件夹 如果目录存在则清空
def empty_and_create_dir(path):
if os.path.exists(path) is False:
os.makedirs(path)
else:
shutil.rmtree(path)
os.makedirs(path)
| 350 | Python | .py | 13 | 18.692308 | 37 | 0.679443 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,540 | colorprinter.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/colorprinter.py | from colorama import Fore, Back, Style
def print_red(text):
color_text = Fore.RED + str(text) + Style.RESET_ALL
print(color_text)
def print_green(text):
color_text = Fore.GREEN + str(text) + Style.RESET_ALL
print(color_text)
def print_yellow(text):
color_text = Fore.YELLOW + str(text) + Style.RESET_ALL
print(color_text)
def print_blue(text):
color_text = Fore.BLUE + str(text) + Style.RESET_ALL
print(color_text)
def print_magenta(text):
color_text = Fore.MAGENTA + str(text) + Style.RESET_ALL
print(color_text)
def print_cyan(text):
color_text = Fore.CYAN + str(text) + Style.RESET_ALL
print(color_text)
def print_white(text):
color_text = Fore.WHITE + str(text) + Style.RESET_ALL
print(color_text)
def print_black_bg(text):
color_text = Back.BLACK + str(text) + Style.RESET_ALL
print(color_text)
def print_white_bg(text):
color_text = Back.WHITE + str(text) + Style.RESET_ALL
print(color_text)
| 988 | Python | .py | 28 | 31.071429 | 59 | 0.694268 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,541 | model_handler.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/model_handler.py | import torch
def load_model(repo_dir, model_load_path, source='local', device='cpu'):
if source != 'local':
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) # force_reload = recache latest code
return model
model = torch.hub.load(repo_dir, 'custom', path=model_load_path, source=source, device=device)
model.eval()
return model
| 387 | Python | .py | 8 | 43.125 | 118 | 0.692308 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,542 | init_database.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/init_database.py | from werkzeug.security import generate_password_hash
from database_models import *
from batch_add_user import add_users
from weights_init import *
def init_role():
with app.app_context():
admin = RoleModel(role_name='admin', role_desc='管理员')
user = RoleModel(role_name='user', role_desc='普通用户')
db.session.add_all([admin, user])
db.session.commit()
def init_user():
with app.app_context():
root = UserModel(email='[email protected]',
username='root',
password=generate_password_hash('root'),
role_id=1)
admin = UserModel(email='[email protected]',
username='admin',
password=generate_password_hash('admin'),
role_id=1)
user = UserModel(email='[email protected]',
username='user',
password=generate_password_hash('user'),
role_id=2)
test01 = UserModel(email='[email protected]',
username='test01',
password=generate_password_hash('test'),
role_id=2,
status=True)
test02 = UserModel(email='[email protected]',
username='test02',
password=generate_password_hash('test'),
role_id=2,
status=False)
test03 = UserModel(email='[email protected]',
username='test03',
password=generate_password_hash('test'),
role_id=2,
status=False)
db.session.add_all([root, admin, user, test01, test02, test03])
db.session.commit()
def init_dataset():
with app.app_context():
COCO_dataset = DatasetModel(dataset_name='COCO',
class_num=80,
total_num=123287,
train_num=118287,
val_num=5000,
test_exist=False,
test_num=20288)
Sample_dataset = DatasetModel(dataset_name='Sample',
class_num=6,
total_num=1200,
train_num=972,
val_num=108,
test_num=120)
TACO_dataset = DatasetModel(dataset_name='TACO',
class_num=8,
total_num=1086,
train_num=869,
val_num=108,
test_num=109)
Garbage_dataset = DatasetModel(dataset_name='Garbage',
class_num=43,
total_num=14964,
train_num=12120,
val_num=1347,
test_num=1497)
db.session.add_all([COCO_dataset,
Sample_dataset,
TACO_dataset,
Garbage_dataset])
db.session.commit()
if __name__ == '__main__':
init_role()
init_user()
init_dataset()
init_COCO_weights()
init_Sample_weights()
init_TACO_weights()
init_Garbage_weights()
add_users(2000)
| 3,637 | Python | .py | 82 | 23.792683 | 71 | 0.427803 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,543 | weights_init.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/weights_init.py | from app import app
from extensions import db
from database_models import WeightsModel
def init_COCO_weights():
with app.app_context():
COCO_yolov5n = WeightsModel(weights_name='COCO_yolov5n',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5n.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5s = WeightsModel(weights_name='COCO_yolov5s',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5s.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5m = WeightsModel(weights_name='COCO_yolov5m',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5m.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5l = WeightsModel(weights_name='COCO_yolov5l',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5l.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5x = WeightsModel(weights_name='COCO_yolov5x',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5x.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5n6 = WeightsModel(weights_name='COCO_yolov5n6',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5n6.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5s6 = WeightsModel(weights_name='COCO_yolov5s6',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5s6.pt',
weights_version='yolov5-7.0',
enable=True,
dataset_id=1)
COCO_yolov5m6 = WeightsModel(weights_name='COCO_yolov5m6',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5m6.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5l6 = WeightsModel(weights_name='COCO_yolov5l6',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5l6.pt',
weights_version='yolov5-7.0',
dataset_id=1)
COCO_yolov5x6 = WeightsModel(weights_name='COCO_yolov5x6',
weights_relative_path='weights/yolov5-7.0/COCO_yolov5x6.pt',
weights_version='yolov5-7.0',
dataset_id=1)
db.session.add_all([COCO_yolov5n,
COCO_yolov5s,
COCO_yolov5m,
COCO_yolov5l,
COCO_yolov5x,
COCO_yolov5n6,
COCO_yolov5s6,
COCO_yolov5m6,
COCO_yolov5l6,
COCO_yolov5x6])
db.session.commit()
def init_Sample_weights():
with app.app_context():
Sample_yolov5n_300_epochs = WeightsModel(weights_name='Sample_yolov5n_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5n_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5s_300_epochs = WeightsModel(weights_name='Sample_yolov5s_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5s_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5l_300_epochs = WeightsModel(weights_name='Sample_yolov5l_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5l_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5m_300_epochs = WeightsModel(weights_name='Sample_yolov5m_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5m_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5x_300_epochs = WeightsModel(weights_name='Sample_yolov5x_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5x_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5n6_300_epochs = WeightsModel(weights_name='Sample_yolov5n6_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5n6_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5s6_300_epochs = WeightsModel(weights_name='Sample_yolov5s6_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5s6_300_epochs.pt',
weights_version='yolov5-6.2',
enable=True,
dataset_id=2)
Sample_yolov5l6_300_epochs = WeightsModel(weights_name='Sample_yolov5l6_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5l6_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5m6_300_epochs = WeightsModel(weights_name='Sample_yolov5m6_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5m6_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
Sample_yolov5x6_300_epochs = WeightsModel(weights_name='Sample_yolov5x6_300_epochs',
weights_relative_path='weights/yolov5-6.2/Sample_yolov5x6_300_epochs.pt',
weights_version='yolov5-6.2',
dataset_id=2)
db.session.add_all([Sample_yolov5n_300_epochs,
Sample_yolov5s_300_epochs,
Sample_yolov5m_300_epochs,
Sample_yolov5l_300_epochs,
Sample_yolov5x_300_epochs,
Sample_yolov5n6_300_epochs,
Sample_yolov5s6_300_epochs,
Sample_yolov5m6_300_epochs,
Sample_yolov5l6_300_epochs,
Sample_yolov5x6_300_epochs])
db.session.commit()
def init_TACO_weights():
with app.app_context():
TACO_yolov5s_300_epochs = WeightsModel(weights_name='TACO_yolov5s_300_epochs',
weights_relative_path='weights/yolov5-3.1/TACO_yolov5s_300_epochs.pt',
weights_version='yolov5-3.1',
enable=True,
dataset_id=3)
TACO_yolov5l_300_epochs = WeightsModel(weights_name='TACO_yolov5l_300_epochs',
weights_relative_path='weights/yolov5-3.1/TACO_yolov5l_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=3)
TACO_yolov5m_300_epochs = WeightsModel(weights_name='TACO_yolov5m_300_epochs',
weights_relative_path='weights/yolov5-3.1/TACO_yolov5m_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=3)
TACO_yolov5x_300_epochs = WeightsModel(weights_name='TACO_yolov5x_300_epochs',
weights_relative_path='weights/yolov5-3.1/TACO_yolov5x_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=3)
db.session.add_all([TACO_yolov5s_300_epochs,
TACO_yolov5m_300_epochs,
TACO_yolov5l_300_epochs,
TACO_yolov5x_300_epochs])
db.session.commit()
def init_Garbage_weights():
with app.app_context():
Garbage_yolov5s_300_epochs = WeightsModel(weights_name='Garbage_yolov5s_300_epochs',
weights_relative_path='weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt',
weights_version='yolov5-3.1',
enable=True,
dataset_id=4)
Garbage_yolov5l_300_epochs = WeightsModel(weights_name='Garbage_yolov5l_300_epochs',
weights_relative_path='weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=4)
Garbage_yolov5m_300_epochs = WeightsModel(weights_name='Garbage_yolov5m_300_epochs',
weights_relative_path='weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=4)
Garbage_yolov5x_300_epochs = WeightsModel(weights_name='Garbage_yolov5x_300_epochs',
weights_relative_path='weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt',
weights_version='yolov5-3.1',
dataset_id=4)
db.session.add_all([Garbage_yolov5s_300_epochs,
Garbage_yolov5m_300_epochs,
Garbage_yolov5l_300_epochs,
Garbage_yolov5x_300_epochs])
db.session.commit()
if __name__ == '__main__':
init_COCO_weights()
init_Sample_weights()
init_TACO_weights()
init_Garbage_weights()
| 10,204 | Python | .py | 164 | 38.487805 | 104 | 0.503389 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,544 | response_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/response_utils.py | from flask import jsonify
from sqlalchemy.orm import DeclarativeMeta
def response(code=200, message='', data=None):
"""
自定义返回结果的封装函数
:param code: 状态码，默认为 200
:param message: 提示信息，默认为空字符串
:param data: 返回数据，默认为 None
:return: Response 对象
"""
response_data = {
'code': code,
'message': message,
'data': None
}
try:
response_data['data'] = serialize(data)
return jsonify(response_data)
except SerializationError as e:
response_data['code'] = e.code
response_data['message'] = e.message
return jsonify(response_data)
def serialize(obj):
"""
将对象转换为可以序列化为JSON的数据类型
:param obj: 待转换的对象
:return: 转换后的数据类型
"""
if obj is None:
return None
try:
# 如果对象本身就是可以序列化为JSON的类型，则直接返回
if isinstance(obj, (str, int, float, bool, list, tuple, dict)):
return obj
# 如果对象是ORM对象，则将其转换为字典并返回
elif isinstance(obj.__class__, DeclarativeMeta):
return {c.name: getattr(obj, c.name) for c in obj.__table__.columns}
# 如果对象实现了__dict__方法，则将其转换为字典并返回
elif hasattr(obj, '__dict__'):
return obj.__dict__
# 如果对象是其他类型，则抛出异常
else:
raise SerializationError(code=500, message='Cannot serialize object')
except Exception as e:
raise SerializationError(code=500, message=str(e))
class SerializationError(Exception):
"""
自定义的异常类，用于处理序列化错误
"""
def __init__(self, code, message):
self.code = code
self.message = message
| 1,908 | Python | .py | 52 | 23.384615 | 81 | 0.621372 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,545 | batch_add_user.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/batch_add_user.py | import random
import string
from app import app
from extensions import db
from database_models import UserModel, RoleModel
def generate_password(length=8):
"""生成随机密码"""
letters = string.ascii_letters + string.digits
return ''.join(random.choice(letters) for i in range(length))
def add_users(num):
"""批量添加用户"""
with app.app_context():
for i in range(1, num+1):
username = f"工具人{i}号"
password = generate_password()
email = f"user{i}@example.com"
user_role = random.choice(RoleModel.query.all())
user_status = random.choice([True, False])
user = UserModel(username=username, password=password, email=email, roles=user_role, status=user_status)
db.session.add(user)
db.session.commit()
if __name__ == '__main__':
add_users(2000)
| 889 | Python | .py | 23 | 30.565217 | 116 | 0.648126 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,546 | email_utils.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/backend_utils/email_utils.py | import smtplib
import config
from email.mime.text import MIMEText
from email.header import Header
import random
class EmailOP:
def __init__(self, host, port, user, password):
"""
host：邮件服务器地址
port：邮件服务器端口
username：邮箱账户名
password：邮箱账户的授权码（注意是授权码，不是邮箱的登录密码）
"""
self.user = user
self.password = password
self.smtp = smtplib.SMTP() # 创建SMTP对象
self.smtp.connect(host=host, port=port) # 连接到SMTP服务器
self.smtp.login(user=self.user, password=self.password) # 登录邮箱
def send(self, subject, body, recipient_name, recipient_email,
sender_name='基于深度学习算法的垃圾检测系统'):
"""
subject：邮件主题
body：邮件正文
sender_name：发送者昵称
recipient_name：收件人昵称
recipient_email: 收件人邮箱地址
"""
message = MIMEText(body, 'plain', 'utf-8')
message['From'] = Header(sender_name)
message['To'] = Header(recipient_name)
message['Subject'] = Header(subject)
self.smtp.sendmail(from_addr=self.user, to_addrs=recipient_email, msg=message.as_string())
# port=25/587
# port=465时连接超时
email_op = EmailOP(host=config.MAIL_SERVER,
port=587,
user=config.MAIL_USERNAME,
password=config.MAIL_PASSWORD)
if __name__ == '__main__':
captcha = random.randint(10000, 99999)
email_op.send(recipient_name='[email protected]',
recipient_email='[email protected]',
subject='测试邮件',
body=f'您的验证码：{captcha}')
| 1,794 | Python | .py | 44 | 26.704545 | 98 | 0.609073 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,547 | resume.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/utils/aws/resume.py | # Resume all interrupted trainings in yolov5/ dir including DDP trainings
# Usage: $ python utils/aws/resume.py
import os
import sys
from pathlib import Path
import torch
import yaml
FILE = Path(__file__).resolve()
ROOT = FILE.parents[2] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
port = 0 # --master_port
path = Path('').resolve()
for last in path.rglob('*/**/last.pt'):
ckpt = torch.load(last)
if ckpt['optimizer'] is None:
continue
# Load opt.yaml
with open(last.parent.parent / 'opt.yaml', errors='ignore') as f:
opt = yaml.safe_load(f)
# Get device count
d = opt['device'].split(',') # devices
nd = len(d) # number of devices
ddp = nd > 1 or (nd == 0 and torch.cuda.device_count() > 1) # distributed data parallel
if ddp: # multi-GPU
port += 1
cmd = f'python -m torch.distributed.run --nproc_per_node {nd} --master_port {port} train.py --resume {last}'
else: # single-GPU
cmd = f'python train.py --resume {last}'
cmd += ' > /dev/null 2>&1 &' # redirect output to dev/null and run in daemon thread
print(cmd)
os.system(cmd)
| 1,198 | Python | .py | 32 | 33.1875 | 116 | 0.647668 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,548 | response_utils02.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/response_utils/response_utils02.py | from flask import jsonify
from sqlalchemy.orm import DeclarativeMeta
def response(code=200, message='', data=None):
"""
自定义返回结果的封装函数
:param code: 状态码，默认为 200
:param message: 提示信息，默认为空字符串
:param data: 返回数据，默认为 None
:return: Response 对象
"""
response_data = {
'code': code,
'message': message,
'data': None
}
try:
response_data['data'] = serialize(data)
return jsonify(response_data)
except SerializationError as e:
response_data['code'] = e.code
response_data['message'] = e.message
return jsonify(response_data)
def serialize(obj):
"""
将对象转换为可以序列化为JSON的数据类型
:param obj: 待转换的对象
:return: 转换后的数据类型
"""
if obj is None:
return None
try:
# 如果对象本身就是可以序列化为JSON的类型，则直接返回
if isinstance(obj, (str, int, float, bool, list, tuple, dict)):
return obj
# 如果对象是ORM对象，则将其转换为字典并返回
elif isinstance(obj.__class__, DeclarativeMeta):
return {c.name: getattr(obj, c.name) for c in obj.__table__.columns}
# 如果对象实现了__dict__方法，则将其转换为字典并返回
elif hasattr(obj, '__dict__'):
return obj.__dict__
# 如果对象是其他类型，则抛出异常
else:
raise SerializationError(code=500, message='Cannot serialize object')
except Exception as e:
raise SerializationError(code=500, message=str(e))
class SerializationError(Exception):
"""
自定义的异常类，用于处理序列化错误
"""
def __init__(self, code, message):
self.code = code
self.message = message
| 1,908 | Python | .py | 52 | 23.384615 | 81 | 0.621372 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,549 | response_utils01.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/response_utils/response_utils01.py | from flask import jsonify
def response(code=200, message='', data=None):
"""
自定义返回结果的封装函数
:param code: 状态码，默认为 200
:param message: 提示信息，默认为空字符串
:param data: 返回数据，默认为 None
:return: Response 对象
"""
response_data = {
'code': code,
'message': message,
'data': data
}
return jsonify(response_data)
| 441 | Python | .py | 15 | 18.533333 | 46 | 0.616959 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,550 | 03_Base64_Results_Example.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/example/Load_YOLOv5_from_PyTorch_Hub/03_Base64_Results_Example.py | # https://github.com/ultralytics/yolov5/pull/2291#issuecomment-786666152
import base64
import cv2
import torch
from PIL import Image
from io import BytesIO
# Model
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) # for file/URI/PIL/cv2/np inputs and NMS
# Images
for f in ['zidane.jpg', 'bus.jpg']: # download 2 images
print(f'Downloading {f}...')
torch.hub.download_url_to_file('https://github.com/ultralytics/yolov5/releases/download/v1.0/' + f, f)
img1 = Image.open('zidane.jpg') # PIL image
img2 = cv2.imread('bus.jpg')[:, :, ::-1] # OpenCV image (BGR to RGB)
imgs = [img1, img2] # batched list of images
# Inference
results = model(imgs, size=640) # includes NMS
# Results
results.print() # print results to screen
results.show() # display results
results.save() # save as results1.jpg, results2.jpg... etc.
# Data
print('\n', results.xyxy[0]) # print img1 predictions
# x1 (pixels) y1 (pixels) x2 (pixels) y2 (pixels) confidence class
# tensor([[7.47613e+02, 4.01168e+01, 1.14978e+03, 7.12016e+02, 8.71210e-01, 0.00000e+00],
# [1.17464e+02, 1.96875e+02, 1.00145e+03, 7.11802e+02, 8.08795e-01, 0.00000e+00],
# [4.23969e+02, 4.30401e+02, 5.16833e+02, 7.20000e+02, 7.77376e-01, 2.70000e+01],
# [9.81310e+02, 3.10712e+02, 1.03111e+03, 4.19273e+02, 2.86850e-01, 2.70000e+01]])
# Transform images with predictions from numpy arrays to base64 encoded images
results.imgs # array of original images (as np array) passed to model for inference
results.render() # updates results.imgs with boxes and labels, returns nothing
for img in results.imgs:
buffered = BytesIO()
img_base64 = Image.fromarray(img)
img_base64.save(buffered, format="JPEG")
print(base64.b64encode(buffered.getvalue()).decode('utf-8')) # base64 encoded image with results | 1,848 | Python | .py | 36 | 49.5 | 114 | 0.707087 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,551 | 01_Simple Example.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/example/Load_YOLOv5_from_PyTorch_Hub/01_Simple Example.py | import torch
# Model
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
# Image
im = 'https://ultralytics.com/images/zidane.jpg'
# Inference
results = model(im)
results.pandas().xyxy[0]
# xmin ymin xmax ymax confidence class name
# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie | 504 | Python | .py | 13 | 37.538462 | 61 | 0.622951 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,552 | 02_Detailed Example.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/example/Load_YOLOv5_from_PyTorch_Hub/02_Detailed Example.py | import cv2
import torch
from PIL import Image
# Model
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
# Images
for f in 'zidane.jpg', 'bus.jpg':
torch.hub.download_url_to_file('https://ultralytics.com/images/' + f, f) # download 2 images
im1 = Image.open('zidane.jpg') # PIL image
im2 = cv2.imread('bus.jpg')[..., ::-1] # OpenCV image (BGR to RGB)
# Inference
results = model([im1, im2], size=640) # batch of images
# Results
results.print()
results.save() # or .show()
results.xyxy[0] # im1 predictions (tensor)
results.pandas().xyxy[0] # im1 predictions (pandas)
# xmin ymin xmax ymax confidence class name
# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie | 897 | Python | .py | 22 | 39.409091 | 97 | 0.646383 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,553 | tutorial.ipynb | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/yolov5_backup/tutorial.ipynb | {
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "YOLOv5 Tutorial",
"provenance": [],
"collapsed_sections": [],
"machine_shape": "hm",
"toc_visible": true,
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"accelerator": "GPU",
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"c31d2039ccf74c22b67841f4877d1186": {
"model_module": "@jupyter-widgets/controls",
"model_name": "HBoxModel",
"model_module_version": "1.5.0",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "1.5.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_d4bba1727c714d94ad58a72bffa07c4c",
"IPY_MODEL_9aeff9f1780b45f892422fdc96e56913",
"IPY_MODEL_bf55a7c71d074d3fa88b10b997820825"
],
"layout": "IPY_MODEL_d8b66044e2fb4f5b916696834d880c81"
}
},
"d4bba1727c714d94ad58a72bffa07c4c": {
"model_module": "@jupyter-widgets/controls",
"model_name": "HTMLModel",
"model_module_version": "1.5.0",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "1.5.0",
"_view_name": "HTMLView",
"description": "",
"description_tooltip": null,
"layout": "IPY_MODEL_102e1deda239436fa72751c58202fa0f",
"placeholder": "‚Äã",
"style": "IPY_MODEL_4fd4431ced6c42368e18424912b877e4",
"value": "100%"
}
},
"9aeff9f1780b45f892422fdc96e56913": {
"model_module": "@jupyter-widgets/controls",
"model_name": "FloatProgressModel",
"model_module_version": "1.5.0",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "1.5.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_tooltip": null,
"layout": "IPY_MODEL_cdd709c4f40941bea1b2053523c9fac8",
"max": 818322941,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_a1ef2d8de2b741c78ca5d938e2ddbcdf",
"value": 818322941
}
},
"bf55a7c71d074d3fa88b10b997820825": {
"model_module": "@jupyter-widgets/controls",
"model_name": "HTMLModel",
"model_module_version": "1.5.0",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "1.5.0",
"_view_name": "HTMLView",
"description": "",
"description_tooltip": null,
"layout": "IPY_MODEL_0dbce99bb6184238842cbec0587d564a",
"placeholder": "‚Äã",
"style": "IPY_MODEL_91ff5f93f2a24c5790ab29e347965946",
"value": " 780M/780M [01:10<00:00, 10.5MB/s]"
}
},
"d8b66044e2fb4f5b916696834d880c81": {
"model_module": "@jupyter-widgets/base",
"model_name": "LayoutModel",
"model_module_version": "1.2.0",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "1.2.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"overflow_x": null,
"overflow_y": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"102e1deda239436fa72751c58202fa0f": {
"model_module": "@jupyter-widgets/base",
"model_name": "LayoutModel",
"model_module_version": "1.2.0",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "1.2.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"overflow_x": null,
"overflow_y": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"4fd4431ced6c42368e18424912b877e4": {
"model_module": "@jupyter-widgets/controls",
"model_name": "DescriptionStyleModel",
"model_module_version": "1.5.0",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "DescriptionStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "StyleView",
"description_width": ""
}
},
"cdd709c4f40941bea1b2053523c9fac8": {
"model_module": "@jupyter-widgets/base",
"model_name": "LayoutModel",
"model_module_version": "1.2.0",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "1.2.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"overflow_x": null,
"overflow_y": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"a1ef2d8de2b741c78ca5d938e2ddbcdf": {
"model_module": "@jupyter-widgets/controls",
"model_name": "ProgressStyleModel",
"model_module_version": "1.5.0",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"0dbce99bb6184238842cbec0587d564a": {
"model_module": "@jupyter-widgets/base",
"model_name": "LayoutModel",
"model_module_version": "1.2.0",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "1.2.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"overflow_x": null,
"overflow_y": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"91ff5f93f2a24c5790ab29e347965946": {
"model_module": "@jupyter-widgets/controls",
"model_name": "DescriptionStyleModel",
"model_module_version": "1.5.0",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "1.5.0",
"_model_name": "DescriptionStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "1.2.0",
"_view_name": "StyleView",
"description_width": ""
}
}
}
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "t6MPjfT5NrKQ"
},
"source": [
"<a align=\"left\" href=\"https://ultralytics.com/yolov5\" target=\"_blank\">\n",
"<img width=\"1024\", src=\"https://user-images.githubusercontent.com/26833433/125273437-35b3fc00-e30d-11eb-9079-46f313325424.png\"></a>\n",
"\n",
"This is the **official YOLOv5 üöÄ notebook** by **Ultralytics**, and is freely available for redistribution under the [GPL-3.0 license](https://choosealicense.com/licenses/gpl-3.0/). \n",
"For more information please visit https://github.com/ultralytics/yolov5 and https://ultralytics.com. Thank you!"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "7mGmQbAO5pQb"
},
"source": [
"# Setup\n",
"\n",
"Clone repo, install dependencies and check PyTorch and GPU."
]
},
{
"cell_type": "code",
"metadata": {
"id": "wbvMlHd_QwMG",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "185d0979-edcd-4860-e6fb-b8a27dbf5096"
},
"source": [
"!git clone https://github.com/ultralytics/yolov5 # clone\n",
"%cd yolov5\n",
"%pip install -qr requirements.txt # install\n",
"\n",
"import torch\n",
"import utils\n",
"display = utils.notebook_init() # checks"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"YOLOv5 üöÄ v6.1-370-g20f1b7e Python-3.7.13 torch-1.12.0+cu113 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n"
]
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"Setup complete ‚úÖ (8 CPUs, 51.0 GB RAM, 37.4/166.8 GB disk)\n"
]
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4JnkELT0cIJg"
},
"source": [
"# 1. Inference\n",
"\n",
"`detect.py` runs YOLOv5 inference on a variety of sources, downloading models automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases), and saving results to `runs/detect`. Example inference sources are:\n",
"\n",
"```shell\n",
"python detect.py --source 0 # webcam\n",
" img.jpg # image \n",
" vid.mp4 # video\n",
" path/ # directory\n",
" 'path/*.jpg' # glob\n",
" 'https://youtu.be/Zgi9g1ksQHc' # YouTube\n",
" 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream\n",
"```"
]
},
{
"cell_type": "code",
"metadata": {
"id": "zR9ZbuQCH7FX",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "4b13989f-32a4-4ef0-b403-06ff3aac255c"
},
"source": [
"!python detect.py --weights yolov5s.pt --img 640 --conf 0.25 --source data/images\n",
"#display.Image(filename='runs/detect/exp/zidane.jpg', width=600)"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\u001b[34m\u001b[1mdetect: \u001b[0mweights=['yolov5s.pt'], source=data/images, data=data/coco128.yaml, imgsz=[640, 640], conf_thres=0.25, iou_thres=0.45, max_det=1000, device=, view_img=False, save_txt=False, save_conf=False, save_crop=False, nosave=False, classes=None, agnostic_nms=False, augment=False, visualize=False, update=False, project=runs/detect, name=exp, exist_ok=False, line_thickness=3, hide_labels=False, hide_conf=False, half=False, dnn=False\n",
"YOLOv5 üöÄ v6.1-370-g20f1b7e Python-3.7.13 torch-1.12.0+cu113 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n",
"\n",
"Downloading https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5s.pt to yolov5s.pt...\n",
"100% 14.1M/14.1M [00:00<00:00, 53.9MB/s]\n",
"\n",
"Fusing layers... \n",
"YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients\n",
"image 1/2 /content/yolov5/data/images/bus.jpg: 640x480 4 persons, 1 bus, Done. (0.016s)\n",
"image 2/2 /content/yolov5/data/images/zidane.jpg: 384x640 2 persons, 2 ties, Done. (0.021s)\n",
"Speed: 0.6ms pre-process, 18.6ms inference, 25.0ms NMS per image at shape (1, 3, 640, 640)\n",
"Results saved to \u001b[1mruns/detect/exp\u001b[0m\n"
]
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hkAzDWJ7cWTr"
},
"source": [
" \n",
"<img align=\"left\" src=\"https://user-images.githubusercontent.com/26833433/127574988-6a558aa1-d268-44b9-bf6b-62d4c605cc72.jpg\" width=\"600\">"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0eq1SMWl6Sfn"
},
"source": [
"# 2. Validate\n",
"Validate a model's accuracy on [COCO](https://cocodataset.org/#home) val or test-dev datasets. Models are downloaded automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases). To show results by class use the `--verbose` flag. Note that `pycocotools` metrics may be ~1% better than the equivalent repo metrics, as is visible below, due to slight differences in mAP computation."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eyTZYGgRjnMc"
},
"source": [
"## COCO val\n",
"Download [COCO val 2017](https://github.com/ultralytics/yolov5/blob/74b34872fdf41941cddcf243951cdb090fbac17b/data/coco.yaml#L14) dataset (1GB - 5000 images), and test model accuracy."
]
},
{
"cell_type": "code",
"metadata": {
"id": "WQPtK1QYVaD_",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 49,
"referenced_widgets": [
"c31d2039ccf74c22b67841f4877d1186",
"d4bba1727c714d94ad58a72bffa07c4c",
"9aeff9f1780b45f892422fdc96e56913",
"bf55a7c71d074d3fa88b10b997820825",
"d8b66044e2fb4f5b916696834d880c81",
"102e1deda239436fa72751c58202fa0f",
"4fd4431ced6c42368e18424912b877e4",
"cdd709c4f40941bea1b2053523c9fac8",
"a1ef2d8de2b741c78ca5d938e2ddbcdf",
"0dbce99bb6184238842cbec0587d564a",
"91ff5f93f2a24c5790ab29e347965946"
]
},
"outputId": "a9004b06-37a6-41ed-a1f2-ac956f3963b3"
},
"source": [
"# Download COCO val\n",
"torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n",
"!unzip -q tmp.zip -d ../datasets && rm tmp.zip"
],
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
" 0%| | 0.00/780M [00:00<?, ?B/s]"
],
"application/vnd.jupyter.widget-view+json": {
"version_major": 2,
"version_minor": 0,
"model_id": "c31d2039ccf74c22b67841f4877d1186"
}
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"metadata": {
"id": "X58w8JLpMnjH",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "c0f29758-4ec8-4def-893d-0efd6ed5b7f4"
},
"source": [
"# Run YOLOv5x on COCO val\n",
"!python val.py --weights yolov5x.pt --data coco.yaml --img 640 --iou 0.65 --half"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\u001b[34m\u001b[1mval: \u001b[0mdata=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False\n",
"YOLOv5 üöÄ v6.1-370-g20f1b7e Python-3.7.13 torch-1.12.0+cu113 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n",
"\n",
"Downloading https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5x.pt to yolov5x.pt...\n",
"100% 166M/166M [00:35<00:00, 4.97MB/s]\n",
"\n",
"Fusing layers... \n",
"YOLOv5x summary: 444 layers, 86705005 parameters, 0 gradients\n",
"Downloading https://ultralytics.com/assets/Arial.ttf to /root/.config/Ultralytics/Arial.ttf...\n",
"100% 755k/755k [00:00<00:00, 49.4MB/s]\n",
"\u001b[34m\u001b[1mval: \u001b[0mScanning '/content/datasets/coco/val2017' images and labels...4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00<00:00, 10716.86it/s]\n",
"\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /content/datasets/coco/val2017.cache\n",
" Class Images Labels P R [email protected] [email protected]:.95: 100% 157/157 [01:08<00:00, 2.28it/s]\n",
" all 5000 36335 0.743 0.625 0.683 0.504\n",
"Speed: 0.1ms pre-process, 4.6ms inference, 1.2ms NMS per image at shape (32, 3, 640, 640)\n",
"\n",
"Evaluating pycocotools mAP... saving runs/val/exp/yolov5x_predictions.json...\n",
"loading annotations into memory...\n",
"Done (t=0.41s)\n",
"creating index...\n",
"index created!\n",
"Loading and preparing results...\n",
"DONE (t=5.64s)\n",
"creating index...\n",
"index created!\n",
"Running per image evaluation...\n",
"Evaluate annotation type *bbox*\n",
"DONE (t=72.86s).\n",
"Accumulating evaluation results...\n",
"DONE (t=14.20s).\n",
" Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.506\n",
" Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.688\n",
" Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.549\n",
" Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.340\n",
" Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.558\n",
" Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.651\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.382\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.631\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.684\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.528\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.737\n",
" Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.833\n",
"Results saved to \u001b[1mruns/val/exp\u001b[0m\n"
]
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rc_KbFk0juX2"
},
"source": [
"## COCO test\n",
"Download [COCO test2017](https://github.com/ultralytics/yolov5/blob/74b34872fdf41941cddcf243951cdb090fbac17b/data/coco.yaml#L15) dataset (7GB - 40,000 images), to test model accuracy on test-dev set (**20,000 images, no labels**). Results are saved to a `*.json` file which should be **zipped** and submitted to the evaluation server at https://competitions.codalab.org/competitions/20794."
]
},
{
"cell_type": "code",
"metadata": {
"id": "V0AJnSeCIHyJ"
},
"source": [
"# Download COCO test-dev2017\n",
"!bash data/scripts/get_coco.sh --test"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "29GJXAP_lPrt"
},
"source": [
"# Run YOLOv5x on COCO test\n",
"!python val.py --weights yolov5x.pt --data coco.yaml --img 640 --iou 0.65 --half --task test"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZY2VXXXu74w5"
},
"source": [
"# 3. Train\n",
"\n",
"<p align=\"\"><a href=\"https://roboflow.com/?ref=ultralytics\"><img width=\"1000\" src=\"https://uploads-ssl.webflow.com/5f6bc60e665f54545a1e52a5/615627e5824c9c6195abfda9_computer-vision-cycle.png\"/></a></p>\n",
"Close the active learning loop by sampling images from your inference conditions with the `roboflow` pip package\n",
"<br><br>\n",
"\n",
"Train a YOLOv5s model on the [COCO128](https://www.kaggle.com/ultralytics/coco128) dataset with `--data coco128.yaml`, starting from pretrained `--weights yolov5s.pt`, or from randomly initialized `--weights '' --cfg yolov5s.yaml`.\n",
"\n",
"- **Pretrained [Models](https://github.com/ultralytics/yolov5/tree/master/models)** are downloaded\n",
"automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases)\n",
"- **[Datasets](https://github.com/ultralytics/yolov5/tree/master/data)** available for autodownload include: [COCO](https://github.com/ultralytics/yolov5/blob/master/data/coco.yaml), [COCO128](https://github.com/ultralytics/yolov5/blob/master/data/coco128.yaml), [VOC](https://github.com/ultralytics/yolov5/blob/master/data/VOC.yaml), [Argoverse](https://github.com/ultralytics/yolov5/blob/master/data/Argoverse.yaml), [VisDrone](https://github.com/ultralytics/yolov5/blob/master/data/VisDrone.yaml), [GlobalWheat](https://github.com/ultralytics/yolov5/blob/master/data/GlobalWheat2020.yaml), [xView](https://github.com/ultralytics/yolov5/blob/master/data/xView.yaml), [Objects365](https://github.com/ultralytics/yolov5/blob/master/data/Objects365.yaml), [SKU-110K](https://github.com/ultralytics/yolov5/blob/master/data/SKU-110K.yaml).\n",
"- **Training Results** are saved to `runs/train/` with incrementing run directories, i.e. `runs/train/exp2`, `runs/train/exp3` etc.\n",
"<br><br>\n",
"\n",
"A **Mosaic Dataloader** is used for training which combines 4 images into 1 mosaic.\n",
"\n",
"## Train on Custom Data with Roboflow üåü NEW\n",
"\n",
"[Roboflow](https://roboflow.com/?ref=ultralytics) enables you to easily **organize, label, and prepare** a high quality dataset with your own custom data. Roboflow also makes it easy to establish an active learning pipeline, collaborate with your team on dataset improvement, and integrate directly into your model building workflow with the `roboflow` pip package.\n",
"\n",
"- Custom Training Example: [https://blog.roboflow.com/how-to-train-yolov5-on-a-custom-dataset/](https://blog.roboflow.com/how-to-train-yolov5-on-a-custom-dataset/?ref=ultralytics)\n",
"- Custom Training Notebook: [](https://colab.research.google.com/github/roboflow-ai/yolov5-custom-training-tutorial/blob/main/yolov5-custom-training.ipynb)\n",
"<br>\n",
"\n",
"<p align=\"\"><a href=\"https://roboflow.com/?ref=ultralytics\"><img width=\"480\" src=\"https://uploads-ssl.webflow.com/5f6bc60e665f54545a1e52a5/6152a275ad4b4ac20cd2e21a_roboflow-annotate.gif\"/></a></p>Label images lightning fast (including with model-assisted labeling)"
]
},
{
"cell_type": "code",
"metadata": {
"id": "bOy5KI2ncnWd"
},
"source": [
"# Tensorboard (optional)\n",
"%load_ext tensorboard\n",
"%tensorboard --logdir runs/train"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# ClearML (optional)\n",
"%pip install -q clearml\n",
"!clearml-init"
],
"metadata": {
"id": "DQhI6vvaRWjR"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "2fLAV42oNb7M"
},
"source": [
"# Weights & Biases (optional)\n",
"%pip install -q wandb\n",
"import wandb\n",
"wandb.login()"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "1NcFxRcFdJ_O",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "bce1b4bd-1a14-4c07-aebd-6c11e91ad24b"
},
"source": [
"# Train YOLOv5s on COCO128 for 3 epochs\n",
"!python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt --cache"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\u001b[34m\u001b[1mtrain: \u001b[0mweights=yolov5s.pt, cfg=, data=coco128.yaml, hyp=data/hyps/hyp.scratch-low.yaml, epochs=3, batch_size=16, imgsz=640, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, bucket=, cache=ram, image_weights=False, device=, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=8, project=runs/train, name=exp, exist_ok=False, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, seed=0, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest\n",
"\u001b[34m\u001b[1mgithub: \u001b[0mup to date with https://github.com/ultralytics/yolov5 ‚úÖ\n",
"YOLOv5 üöÄ v6.1-370-g20f1b7e Python-3.7.13 torch-1.12.0+cu113 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n",
"\n",
"\u001b[34m\u001b[1mhyperparameters: \u001b[0mlr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0\n",
"\u001b[34m\u001b[1mWeights & Biases: \u001b[0mrun 'pip install wandb' to automatically track and visualize YOLOv5 üöÄ runs in Weights & Biases\n",
"\u001b[34m\u001b[1mClearML: \u001b[0mrun 'pip install clearml' to automatically track, visualize and remotely train YOLOv5 üöÄ runs in ClearML\n",
"\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir runs/train', view at http://localhost:6006/\n",
"\n",
"Dataset not found ⚠️, missing paths ['/content/datasets/coco128/images/train2017']\n",
"Downloading https://ultralytics.com/assets/coco128.zip to coco128.zip...\n",
"100% 6.66M/6.66M [00:00<00:00, 75.2MB/s]\n",
"Dataset download success ‚úÖ (0.7s), saved to \u001b[1m/content/datasets\u001b[0m\n",
"\n",
" from n params module arguments \n",
" 0 -1 1 3520 models.common.Conv [3, 32, 6, 2, 2] \n",
" 1 -1 1 18560 models.common.Conv [32, 64, 3, 2] \n",
" 2 -1 1 18816 models.common.C3 [64, 64, 1] \n",
" 3 -1 1 73984 models.common.Conv [64, 128, 3, 2] \n",
" 4 -1 2 115712 models.common.C3 [128, 128, 2] \n",
" 5 -1 1 295424 models.common.Conv [128, 256, 3, 2] \n",
" 6 -1 3 625152 models.common.C3 [256, 256, 3] \n",
" 7 -1 1 1180672 models.common.Conv [256, 512, 3, 2] \n",
" 8 -1 1 1182720 models.common.C3 [512, 512, 1] \n",
" 9 -1 1 656896 models.common.SPPF [512, 512, 5] \n",
" 10 -1 1 131584 models.common.Conv [512, 256, 1, 1] \n",
" 11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n",
" 12 [-1, 6] 1 0 models.common.Concat [1] \n",
" 13 -1 1 361984 models.common.C3 [512, 256, 1, False] \n",
" 14 -1 1 33024 models.common.Conv [256, 128, 1, 1] \n",
" 15 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n",
" 16 [-1, 4] 1 0 models.common.Concat [1] \n",
" 17 -1 1 90880 models.common.C3 [256, 128, 1, False] \n",
" 18 -1 1 147712 models.common.Conv [128, 128, 3, 2] \n",
" 19 [-1, 14] 1 0 models.common.Concat [1] \n",
" 20 -1 1 296448 models.common.C3 [256, 256, 1, False] \n",
" 21 -1 1 590336 models.common.Conv [256, 256, 3, 2] \n",
" 22 [-1, 10] 1 0 models.common.Concat [1] \n",
" 23 -1 1 1182720 models.common.C3 [512, 512, 1, False] \n",
" 24 [17, 20, 23] 1 229245 models.yolo.Detect [80, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]\n",
"Model summary: 270 layers, 7235389 parameters, 7235389 gradients, 16.6 GFLOPs\n",
"\n",
"Transferred 349/349 items from yolov5s.pt\n",
"\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ‚úÖ\n",
"\u001b[34m\u001b[1moptimizer:\u001b[0m SGD(lr=0.01) with parameter groups 57 weight(decay=0.0), 60 weight(decay=0.0005), 60 bias\n",
"\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(always_apply=False, p=0.01, blur_limit=(3, 7)), MedianBlur(always_apply=False, p=0.01, blur_limit=(3, 7)), ToGray(always_apply=False, p=0.01), CLAHE(always_apply=False, p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))\n",
"\u001b[34m\u001b[1mtrain: \u001b[0mScanning '/content/datasets/coco128/labels/train2017' images and labels...128 found, 0 missing, 2 empty, 0 corrupt: 100% 128/128 [00:00<00:00, 7926.40it/s]\n",
"\u001b[34m\u001b[1mtrain: \u001b[0mNew cache created: /content/datasets/coco128/labels/train2017.cache\n",
"\u001b[34m\u001b[1mtrain: \u001b[0mCaching images (0.1GB ram): 100% 128/128 [00:00<00:00, 975.81it/s]\n",
"\u001b[34m\u001b[1mval: \u001b[0mScanning '/content/datasets/coco128/labels/train2017.cache' images and labels... 128 found, 0 missing, 2 empty, 0 corrupt: 100% 128/128 [00:00<?, ?it/s]\n",
"\u001b[34m\u001b[1mval: \u001b[0mCaching images (0.1GB ram): 100% 128/128 [00:00<00:00, 258.62it/s]\n",
"Plotting labels to runs/train/exp/labels.jpg... \n",
"\n",
"\u001b[34m\u001b[1mAutoAnchor: \u001b[0m4.27 anchors/target, 0.994 Best Possible Recall (BPR). Current anchors are a good fit to dataset ‚úÖ\n",
"Image sizes 640 train, 640 val\n",
"Using 8 dataloader workers\n",
"Logging results to \u001b[1mruns/train/exp\u001b[0m\n",
"Starting training for 3 epochs...\n",
"\n",
" Epoch gpu_mem box obj cls labels img_size\n",
" 0/2 3.76G 0.04529 0.06712 0.01835 323 640: 100% 8/8 [00:05<00:00, 1.59it/s]\n",
" Class Images Labels P R [email protected] [email protected]:.95: 100% 4/4 [00:00<00:00, 4.05it/s]\n",
" all 128 929 0.806 0.593 0.718 0.472\n",
"\n",
" Epoch gpu_mem box obj cls labels img_size\n",
" 1/2 4.79G 0.04244 0.06423 0.01611 236 640: 100% 8/8 [00:00<00:00, 8.11it/s]\n",
" Class Images Labels P R [email protected] [email protected]:.95: 100% 4/4 [00:00<00:00, 4.20it/s]\n",
" all 128 929 0.811 0.615 0.74 0.493\n",
"\n",
" Epoch gpu_mem box obj cls labels img_size\n",
" 2/2 4.79G 0.04695 0.06875 0.0173 189 640: 100% 8/8 [00:00<00:00, 9.12it/s]\n",
" Class Images Labels P R [email protected] [email protected]:.95: 100% 4/4 [00:00<00:00, 4.24it/s]\n",
" all 128 929 0.784 0.634 0.747 0.502\n",
"\n",
"3 epochs completed in 0.003 hours.\n",
"Optimizer stripped from runs/train/exp/weights/last.pt, 14.9MB\n",
"Optimizer stripped from runs/train/exp/weights/best.pt, 14.9MB\n",
"\n",
"Validating runs/train/exp/weights/best.pt...\n",
"Fusing layers... \n",
"Model summary: 213 layers, 7225885 parameters, 0 gradients, 16.4 GFLOPs\n",
" Class Images Labels P R [email protected] [email protected]:.95: 100% 4/4 [00:03<00:00, 1.20it/s]\n",
" all 128 929 0.781 0.637 0.747 0.502\n",
" person 128 254 0.872 0.693 0.81 0.534\n",
" bicycle 128 6 1 0.407 0.68 0.425\n",
" car 128 46 0.743 0.413 0.581 0.247\n",
" motorcycle 128 5 1 0.988 0.995 0.692\n",
" airplane 128 6 0.965 1 0.995 0.717\n",
" bus 128 7 0.706 0.714 0.814 0.697\n",
" train 128 3 1 0.582 0.806 0.477\n",
" truck 128 12 0.602 0.417 0.495 0.271\n",
" boat 128 6 0.961 0.333 0.464 0.224\n",
" traffic light 128 14 0.517 0.155 0.364 0.216\n",
" stop sign 128 2 0.782 1 0.995 0.821\n",
" bench 128 9 0.829 0.539 0.701 0.288\n",
" bird 128 16 0.924 1 0.995 0.655\n",
" cat 128 4 0.891 1 0.995 0.809\n",
" dog 128 9 1 0.659 0.883 0.604\n",
" horse 128 2 0.808 1 0.995 0.672\n",
" elephant 128 17 0.973 0.882 0.936 0.733\n",
" bear 128 1 0.692 1 0.995 0.995\n",
" zebra 128 4 0.872 1 0.995 0.922\n",
" giraffe 128 9 0.865 0.889 0.975 0.736\n",
" backpack 128 6 1 0.547 0.787 0.372\n",
" umbrella 128 18 0.823 0.667 0.889 0.504\n",
" handbag 128 19 0.516 0.105 0.304 0.153\n",
" tie 128 7 0.696 0.714 0.741 0.482\n",
" suitcase 128 4 0.716 1 0.995 0.553\n",
" frisbee 128 5 0.715 0.8 0.8 0.71\n",
" skis 128 1 0.694 1 0.995 0.398\n",
" snowboard 128 7 0.893 0.714 0.855 0.569\n",
" sports ball 128 6 0.659 0.667 0.602 0.307\n",
" kite 128 10 0.683 0.434 0.611 0.242\n",
" baseball bat 128 4 0.838 0.5 0.55 0.146\n",
" baseball glove 128 7 0.572 0.429 0.463 0.294\n",
" skateboard 128 5 0.697 0.6 0.702 0.476\n",
" tennis racket 128 7 0.62 0.429 0.544 0.29\n",
" bottle 128 18 0.591 0.402 0.572 0.295\n",
" wine glass 128 16 0.747 0.921 0.913 0.529\n",
" cup 128 36 0.824 0.639 0.826 0.535\n",
" fork 128 6 1 0.319 0.518 0.353\n",
" knife 128 16 0.768 0.62 0.654 0.374\n",
" spoon 128 22 0.824 0.427 0.65 0.382\n",
" bowl 128 28 0.8 0.643 0.726 0.525\n",
" banana 128 1 0.878 1 0.995 0.208\n",
" sandwich 128 2 1 0 0.62 0.546\n",
" orange 128 4 1 0.896 0.995 0.691\n",
" broccoli 128 11 0.586 0.364 0.481 0.349\n",
" carrot 128 24 0.702 0.589 0.722 0.475\n",
" hot dog 128 2 0.524 1 0.828 0.795\n",
" pizza 128 5 0.811 0.865 0.962 0.695\n",
" donut 128 14 0.653 1 0.964 0.853\n",
" cake 128 4 0.852 1 0.995 0.822\n",
" chair 128 35 0.536 0.571 0.593 0.31\n",
" couch 128 6 1 0.63 0.75 0.518\n",
" potted plant 128 14 0.775 0.738 0.839 0.478\n",
" bed 128 3 1 0 0.72 0.423\n",
" dining table 128 13 0.817 0.348 0.592 0.381\n",
" toilet 128 2 0.782 1 0.995 0.895\n",
" tv 128 2 0.711 1 0.995 0.821\n",
" laptop 128 3 1 0 0.789 0.42\n",
" mouse 128 2 1 0 0.0798 0.0399\n",
" remote 128 8 1 0.611 0.63 0.549\n",
" cell phone 128 8 0.685 0.375 0.428 0.245\n",
" microwave 128 3 0.803 1 0.995 0.767\n",
" oven 128 5 0.42 0.4 0.444 0.306\n",
" sink 128 6 0.288 0.167 0.34 0.247\n",
" refrigerator 128 5 0.632 0.8 0.805 0.572\n",
" book 128 29 0.494 0.207 0.332 0.161\n",
" clock 128 9 0.791 0.889 0.93 0.75\n",
" vase 128 2 0.355 1 0.995 0.895\n",
" scissors 128 1 1 0 0.332 0.0663\n",
" teddy bear 128 21 0.839 0.571 0.767 0.487\n",
" toothbrush 128 5 0.829 0.974 0.962 0.644\n",
"Results saved to \u001b[1mruns/train/exp\u001b[0m\n"
]
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "15glLzbQx5u0"
},
"source": [
"# 4. Visualize"
]
},
{
"cell_type": "markdown",
"source": [
"## ClearML Logging and Automation üåü NEW\n",
"\n",
"[ClearML](https://cutt.ly/yolov5-notebook-clearml) is completely integrated into YOLOv5 to track your experimentation, manage dataset versions and even remotely execute training runs. To enable ClearML (check cells above):\n",
"\n",
"- `pip install clearml`\n",
"- run `clearml-init` to connect to a ClearML server (**deploy your own [open-source server](https://github.com/allegroai/clearml-server)**, or use our [free hosted server](https://cutt.ly/yolov5-notebook-clearml))\n",
"\n",
"You'll get all the great expected features from an experiment manager: live updates, model upload, experiment comparison etc. but ClearML also tracks uncommitted changes and installed packages for example. Thanks to that ClearML Tasks (which is what we call experiments) are also reproducible on different machines! With only 1 extra line, we can schedule a YOLOv5 training task on a queue to be executed by any number of ClearML Agents (workers).\n",
"\n",
"You can use ClearML Data to version your dataset and then pass it to YOLOv5 simply using its unique ID. This will help you keep track of your data without adding extra hassle. Explore the [ClearML Tutorial](https://github.com/ultralytics/yolov5/tree/master/utils/loggers/clearml) for details!\n",
"\n",
"<a href=\"https://cutt.ly/yolov5-notebook-clearml\">\n",
"<img alt=\"ClearML Experiment Management UI\" src=\"https://github.com/thepycoder/clearml_screenshots/raw/main/scalars.jpg\" width=\"1280\"/></a>"
],
"metadata": {
"id": "Lay2WsTjNJzP"
}
},
{
"cell_type": "markdown",
"metadata": {
"id": "DLI1JmHU7B0l"
},
"source": [
"## Weights & Biases Logging\n",
"\n",
"[Weights & Biases](https://wandb.ai/site?utm_campaign=repo_yolo_notebook) (W&B) is integrated with YOLOv5 for real-time visualization and cloud logging of training runs. This allows for better run comparison and introspection, as well improved visibility and collaboration for teams. To enable W&B `pip install wandb`, and then train normally (you will be guided through setup on first use). \n",
"\n",
"During training you will see live updates at [https://wandb.ai/home](https://wandb.ai/home?utm_campaign=repo_yolo_notebook), and you can create and share detailed [Reports](https://wandb.ai/glenn-jocher/yolov5_tutorial/reports/YOLOv5-COCO128-Tutorial-Results--VmlldzozMDI5OTY) of your results. For more information see the [YOLOv5 Weights & Biases Tutorial](https://github.com/ultralytics/yolov5/issues/1289). \n",
"\n",
"<a href=\"https://wandb.ai/glenn-jocher/yolov5_tutorial\">\n",
"<img alt=\"Weights & Biases dashboard\" src=\"https://user-images.githubusercontent.com/26833433/182482859-288a9622-4661-48db-99de-650d1dead5c6.jpg\" width=\"1280\"/></a>"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-WPvRbS5Swl6"
},
"source": [
"## Local Logging\n",
"\n",
"Training results are automatically logged with [Tensorboard](https://www.tensorflow.org/tensorboard) and [CSV](https://github.com/ultralytics/yolov5/pull/4148) loggers to `runs/train`, with a new experiment directory created for each new training as `runs/train/exp2`, `runs/train/exp3`, etc.\n",
"\n",
"This directory contains train and val statistics, mosaics, labels, predictions and augmentated mosaics, as well as metrics and charts including precision-recall (PR) curves and confusion matrices. \n",
"\n",
"<img alt=\"Local logging results\" src=\"https://user-images.githubusercontent.com/26833433/183222430-e1abd1b7-782c-4cde-b04d-ad52926bf818.jpg\" width=\"1280\"/>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Zelyeqbyt3GD"
},
"source": [
"# Environments\n",
"\n",
"YOLOv5 may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):\n",
"\n",
"- **Google Colab and Kaggle** notebooks with free GPU: <a href=\"https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"></a> <a href=\"https://www.kaggle.com/ultralytics/yolov5\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" alt=\"Open In Kaggle\"></a>\n",
"- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/GCP-Quickstart)\n",
"- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/AWS-Quickstart)\n",
"- **Docker Image**. See [Docker Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/Docker-Quickstart) <a href=\"https://hub.docker.com/r/ultralytics/yolov5\"><img src=\"https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker\" alt=\"Docker Pulls\"></a>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6Qu7Iesl0p54"
},
"source": [
"# Status\n",
"\n",
"\n",
"\n",
"If this badge is green, all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify correct operation of YOLOv5 training ([train.py](https://github.com/ultralytics/yolov5/blob/master/train.py)), testing ([val.py](https://github.com/ultralytics/yolov5/blob/master/val.py)), inference ([detect.py](https://github.com/ultralytics/yolov5/blob/master/detect.py)) and export ([export.py](https://github.com/ultralytics/yolov5/blob/master/export.py)) on macOS, Windows, and Ubuntu every 24 hours and on every commit.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IEijrePND_2I"
},
"source": [
"# Appendix\n",
"\n",
"Additional content below for PyTorch Hub, CI, reproducing results, profiling speeds, VOC training, classification training and TensorRT example."
]
},
{
"cell_type": "code",
"metadata": {
"id": "GMusP4OAxFu6"
},
"source": [
"import torch\n",
"\n",
"# PyTorch Hub Model\n",
"model = torch.hub.load('ultralytics/yolov5', 'yolov5s') # or yolov5n - yolov5x6, custom\n",
"\n",
"# Images\n",
"img = 'https://ultralytics.com/images/zidane.jpg' # or file, Path, PIL, OpenCV, numpy, list\n",
"\n",
"# Inference\n",
"results = model(img)\n",
"\n",
"# Results\n",
"results.print() # or .show(), .save(), .crop(), .pandas(), etc."
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "FGH0ZjkGjejy"
},
"source": [
"# YOLOv5 CI\n",
"%%shell\n",
"rm -rf runs # remove runs/\n",
"m=yolov5n # official weights\n",
"b=runs/train/exp/weights/best # best.pt checkpoint\n",
"python train.py --imgsz 64 --batch 32 --weights $m.pt --cfg $m.yaml --epochs 1 --device 0 # train\n",
"for d in 0 cpu; do # devices\n",
" for w in $m $b; do # weights\n",
" python val.py --imgsz 64 --batch 32 --weights $w.pt --device $d # val\n",
" python detect.py --imgsz 64 --weights $w.pt --device $d # detect\n",
" done\n",
"done\n",
"python hubconf.py --model $m # hub\n",
"python models/tf.py --weights $m.pt # build TF model\n",
"python models/yolo.py --cfg $m.yaml # build PyTorch model\n",
"python export.py --weights $m.pt --img 64 --include torchscript # export"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "mcKoSIK2WSzj"
},
"source": [
"# Reproduce\n",
"for x in (f'yolov5{x}' for x in 'nsmlx'):\n",
" !python val.py --weights {x}.pt --data coco.yaml --img 640 --task speed # speed\n",
" !python val.py --weights {x}.pt --data coco.yaml --img 640 --conf 0.001 --iou 0.65 # mAP"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "gogI-kwi3Tye"
},
"source": [
"# Profile\n",
"from utils.torch_utils import profile\n",
"\n",
"m1 = lambda x: x * torch.sigmoid(x)\n",
"m2 = torch.nn.SiLU()\n",
"results = profile(input=torch.randn(16, 3, 640, 640), ops=[m1, m2], n=100)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "BSgFCAcMbk1R"
},
"source": [
"# VOC\n",
"for b, m in zip([64, 64, 64, 32, 16], [f'yolov5{x}' for x in 'nsmlx']): # batch, model\n",
" !python train.py --batch {b} --weights {m}.pt --data VOC.yaml --epochs 50 --img 512 --hyp hyp.VOC.yaml --project VOC --name {m} --cache"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# Classification\n",
"for m in [*(f'yolov5{x}.pt' for x in 'nsmlx'), 'resnet50.pt', 'efficientnet_b0.pt']:\n",
" for d in 'mnist', 'fashion-mnist', 'cifar10', 'cifar100', 'imagenette160', 'imagenette320', 'imagenette', 'imagewoof160', 'imagewoof320', 'imagewoof':\n",
" !python classify/train.py --model {m} --data {d} --epochs 10 --project YOLOv5-cls --name {m}-{d}"
],
"metadata": {
"id": "UWGH7H6yakVl"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "VTRwsvA9u7ln"
},
"source": [
"# TensorRT \n",
"!pip install -U nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com # install\n",
"!python export.py --weights yolov5s.pt --include engine --imgsz 640 --device 0 # export\n",
"!python detect.py --weights yolov5s.engine --imgsz 640 --device 0 # inference"
],
"execution_count": null,
"outputs": []
}
]
} | 58,691 | Python | .py | 1,141 | 41.212095 | 849 | 0.497263 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,554 | load_model_demo.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/load_model/load_model_demo.py | import cv2
import torch
import os
from PIL import Image
# repo_dir = '/Users/saber/Code/Back-end/garbage_detect-backend/'
repo_dir = 'E:/Code/Back-end/garbage_detect-backend/'
weights_path = 'weights/exp3_TACO_yolov5s_300_epochs_3090Ti/weights/best.pt'
model_path = os.path.join(repo_dir, weights_path)
yolov5s_model_path = os.path.join(repo_dir, 'weights/yolov5s.pt')
# Model
# model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
model = torch.hub.load(repo_dir, 'custom', path=model_path, source='local', device='cpu')
# model = torch.hub.load(repo_dir, 'custom', path=yolov5s_model_path, source='local', device='cpu')
# Images
# for f in 'zidane.jpg', 'bus.jpg':
# torch.hub.download_url_to_file('https://ultralytics.com/images/' + f, f) # download 2 images
# im1 = Image.open(os.path.join(repo_dir, 'data/images/zidane.jpg')) # PIL image
# im2 = cv2.imread(os.path.join(repo_dir, 'data/images/bus.jpg'))[..., ::-1] # OpenCV image (BGR to RGB)
im3 = Image.open(os.path.join(repo_dir, 'data/images/batch_1_000029.jpg')) # PIL image
# Inference
# results = model(im1) # batch of images
# results = model([im1, im2], size=640) # batch of images
results = model([im3], size=640) # batch of images
# Results
results.print()
results.save()
# results.show()
# results.save() # or .show()
results.xyxy[0] # im1 predictions (tensor)
results.pandas().xyxy[0] # im1 predictions (pandas)
# xmin ymin xmax ymax confidence class name
# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie | 1,712 | Python | .py | 35 | 47.771429 | 105 | 0.68122 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,555 | base64_results.ipynb | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/load_model/base64_results.ipynb | {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"outputs": [],
"source": [
"import cv2\n",
"import torch\n",
"import os\n",
"from PIL import Image\n",
"import base64\n",
"from io import BytesIO"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 2,
"outputs": [],
"source": [
"repo_dir = os.getcwd()\n",
"# weights_path = 'weights/yolov5-7.0/COCO_yolov5s6.pt'\n",
"# weights_path = 'weights/yolov5-6.2/Sample_yolov5s6_300_epochs.pt'\n",
"weights_path = 'weights/yolov5-3.1/TACO_yolov5s_300_epochs.pt'\n",
"# weights_path = 'weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt'\n",
"model_load_path = os.path.join(repo_dir, weights_path)"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 3,
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"YOLOv5 626dd31 Python-3.8.15 torch-1.12.1+cu113 CPU\n",
"\n",
"Fusing layers... \n",
"YOLOv5s-TACO summary: 232 layers, 7265397 parameters, 0 gradients\n",
"Adding AutoShape... \n"
]
}
],
"source": [
"# Model\n",
"# model = torch.hub.load('ultralytics/yolov5', 'yolov5s')\n",
"model = torch.hub.load(repo_dir, 'custom', path=model_load_path, source='local', device='cpu')\n",
"# model = torch.hub.load(repo_dir, 'custom', path=yolov5s_model_path, source='local', device='cpu')"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 4,
"outputs": [],
"source": [
"# Images\n",
"# im1 = Image.open(os.path.join(repo_dir, 'data/images/zidane.jpg')) # PIL image\n",
"# im2 = cv2.imread(os.path.join(repo_dir, 'data/images/bus.jpg'))[..., ::-1] # OpenCV image (BGR to RGB)\n",
"im3 = Image.open(os.path.join(repo_dir, 'data/images/batch_1_000029.jpg')) # PIL image"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 5,
"outputs": [],
"source": [
"results = model(im3) # inference"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 6,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"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\n"
]
}
],
"source": [
"results.imgs # array of original images (as np array) passed to model for inference\n",
"results.render() # updates results.ims with boxes and labels\n",
"for im in results.imgs:\n",
" buffered = BytesIO()\n",
" im_base64 = Image.fromarray(im)\n",
" im_base64.save(buffered, format=\"JPEG\")\n",
" print(base64.b64encode(buffered.getvalue()).decode('utf-8')) # base64 encoded image with results"
],
"metadata": {
"collapsed": false
}
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.6"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| 726,353 | Python | .py | 133 | 5,457 | 723,046 | 0.976773 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,556 | load_model_base64_demo.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/load_model/load_model_base64_demo.py | import cv2
import torch
import os
from PIL import Image
import base64
from io import BytesIO
# repo_dir = '/Users/saber/Code/Back-end/garbage_detect-backend/'
repo_dir = 'E:/Code/Back-end/garbage_detect-backend/'
weights_path = 'weights/exp3_TACO_yolov5s_300_epochs_3090Ti/weights/best.pt'
model_path = os.path.join(repo_dir, weights_path)
yolov5s_model_path = os.path.join(repo_dir, 'weights/yolov5s.pt')
# Model
# model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
model = torch.hub.load(repo_dir, 'custom', path=model_path, source='local', device='cpu')
# model = torch.hub.load(repo_dir, 'custom', path=yolov5s_model_path, source='local', device='cpu')
# Images
# im1 = Image.open(os.path.join(repo_dir, 'data/images/zidane.jpg')) # PIL image
# im2 = cv2.imread(os.path.join(repo_dir, 'data/images/bus.jpg'))[..., ::-1] # OpenCV image (BGR to RGB)
im3 = Image.open(os.path.join(repo_dir, 'data/images/batch_1_000029.jpg')) # PIL image
results = model(im3) # inference
results.imgs # array of original images (as np array) passed to model for inference
results.render() # updates results.ims with boxes and labels
for im in results.imgs:
buffered = BytesIO()
im_base64 = Image.fromarray(im)
im_base64.save(buffered, format="JPEG")
print(base64.b64encode(buffered.getvalue()).decode('utf-8')) # base64 encoded image with results
# results.print()
# results.save()
results.xyxy[0] # im1 predictions (tensor)
results.pandas().xyxy[0] # im1 predictions (pandas) | 1,498 | Python | .py | 31 | 46.548387 | 105 | 0.73475 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,557 | example01.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/load_model/example01.py | import cv2
import torch
from PIL import Image
# Model
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
# Images
# for f in 'zidane.jpg', 'bus.jpg':
# torch.hub.download_url_to_file('https://ultralytics.com/images/' + f, f) # download 2 images
im1 = Image.open('zidane.jpg') # PIL image
im2 = cv2.imread('bus.jpg')[..., ::-1] # OpenCV image (BGR to RGB)
# Inference
results = model([im1, im2], size=640) # batch of images
# Results
results.print()
# results.save()
results.show()
# results.save() # or .show()
results.xyxy[0] # im1 predictions (tensor)
results.pandas().xyxy[0] # im1 predictions (pandas)
# xmin ymin xmax ymax confidence class name
# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie | 936 | Python | .py | 24 | 37.833333 | 99 | 0.644273 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,558 | load_model.ipynb | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/load_model/load_model.ipynb | {
"cells": [
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import cv2\n",
"import torch\n",
"import os\n",
"from PIL import Image"
]
},
{
"cell_type": "code",
"execution_count": 9,
"outputs": [],
"source": [
"repo_dir = os.getcwd()\n",
"# weights_path = 'weights/yolov5-7.0/COCO_yolov5s6.pt'\n",
"# weights_path = 'weights/yolov5-6.2/Sample_yolov5s6_300_epochs.pt'\n",
"weights_path = 'weights/yolov5-3.1/TACO_yolov5s_300_epochs.pt'\n",
"# weights_path = 'weights/yolov5-3.1/Garbage_yolov5s_300_epochs.pt'\n",
"model_load_path = os.path.join(repo_dir, weights_path)"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 10,
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"YOLOv5 626dd31 Python-3.8.15 torch-1.12.1+cu113 CPU\n",
"\n",
"Fusing layers... \n",
"YOLOv5s-TACO summary: 232 layers, 7265397 parameters, 0 gradients\n",
"Adding AutoShape... \n"
]
}
],
"source": [
"# Model\n",
"# model = torch.hub.load('ultralytics/yolov5', 'yolov5s')\n",
"model = torch.hub.load(repo_dir, 'custom', path=model_load_path, source='local', device='cpu')\n",
"# model = torch.hub.load(repo_dir, 'custom', path=yolov5s_model_path, source='local', device='cpu')"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 11,
"outputs": [],
"source": [
"# Images\n",
"# for f in 'zidane.jpg', 'bus.jpg':\n",
"# torch.hub.download_url_to_file('https://ultralytics.com/images/' + f, f) # download 2 images\n",
"# im1 = Image.open(os.path.join(repo_dir, 'data/images/zidane.jpg')) # PIL image\n",
"# im2 = cv2.imread(os.path.join(repo_dir, 'data/images/bus.jpg'))[..., ::-1] # OpenCV image (BGR to RGB)\n",
"im3 = Image.open(os.path.join(repo_dir, 'data/images/batch_1_000029.jpg')) # PIL image"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 12,
"outputs": [],
"source": [
"# Inference\n",
"# results = model(im1) # batch of images\n",
"# results = model([im1, im2], size=640) # batch of images\n",
"results = model([im3], size=640) # batch of images"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 13,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"image 1/1: 2049x1537 1 Drink can\n",
"Speed: 38.6ms pre-process, 192.3ms inference, 1.0ms NMS per image at shape (1, 3, 640, 512)\n"
]
}
],
"source": [
"# Results\n",
"results.print()\n",
"# results.save()\n",
"results.show()\n",
"# results.save() # or .show()"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "code",
"execution_count": 14,
"outputs": [
{
"data": {
"text/plain": " xmin ymin xmax ymax confidence class \\\n0 654.954285 881.505066 1071.494507 1564.204102 0.915069 2 \n\n name \n0 Drink can ",
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>xmin</th>\n <th>ymin</th>\n <th>xmax</th>\n <th>ymax</th>\n <th>confidence</th>\n <th>class</th>\n <th>name</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>654.954285</td>\n <td>881.505066</td>\n <td>1071.494507</td>\n <td>1564.204102</td>\n <td>0.915069</td>\n <td>2</td>\n <td>Drink can</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"results.xyxy[0] # im1 predictions (tensor)\n",
"results.pandas().xyxy[0] # im1 predictions (pandas)\n",
"# xmin ymin xmax ymax confidence class name\n",
"# 0 749.50 43.50 1148.0 704.5 0.874023 0 person\n",
"# 1 433.50 433.50 517.5 714.5 0.687988 27 tie\n",
"# 2 114.75 195.75 1095.0 708.0 0.624512 0 person\n",
"# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie"
],
"metadata": {
"collapsed": false
}
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.6"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
| 5,160 | Python | .py | 162 | 27.432099 | 813 | 0.540216 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,559 | logging_with_color02.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/logging_with_color/logging_with_color02.py | import logging
from colorama import init, Fore, Style
# 初始化colorama
init()
# 创建Logger对象
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
# 定义一个输出到终端并使用颜色的Handler
class ColorHandler(logging.StreamHandler):
def emit(self, record):
if record.levelno >= logging.ERROR:
color = Fore.RED # 红色
elif record.levelno >= logging.WARNING:
color = Fore.YELLOW # 黄色
elif record.levelno >= logging.INFO:
color = Fore.GREEN # 绿色
else:
color = Style.RESET_ALL # 默认颜色
message = self.format(record)
message = color + message + Style.RESET_ALL # 恢复默认颜色
stream = self.stream
stream.write(message)
stream.write(self.terminator)
# 创建ColorHandler对象，并添加到Logger中
handler = ColorHandler()
logger.addHandler(handler)
# 输出不同级别的日志
logger.debug("debug message")
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
| 1,118 | Python | .py | 32 | 26.34375 | 61 | 0.695967 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,560 | logging_with_color04.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/logging_with_color/logging_with_color04.py | import logging
import colorlog
def get_logger(level=logging.INFO):
# 创建logger对象
logger = logging.getLogger()
logger.setLevel(level)
# 创建控制台日志处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(level)
# 定义颜色输出格式
color_formatter = colorlog.ColoredFormatter(
'%(log_color)s%(levelname)s: %(message)s',
log_colors={
'DEBUG': 'cyan',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white',
}
)
# 将颜色输出格式添加到控制台日志处理器
console_handler.setFormatter(color_formatter)
# 移除默认的handler
for handler in logger.handlers:
logger.removeHandler(handler)
# 将控制台日志处理器添加到logger对象
logger.addHandler(console_handler)
return logger
if __name__ == '__main__':
logger = get_logger(logging.DEBUG)
logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')
| 1,172 | Python | .py | 35 | 23.857143 | 50 | 0.650246 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,561 | logging_with_color03.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/logging_with_color/logging_with_color03.py | import logging
from colorama import init, Fore, Style
def get_logger(level=logging.INFO):
# 初始化colorama
init(autoreset=True)
# 创建Logger对象
logger = logging.getLogger()
logger.setLevel(level)
# 定义一个输出到终端并使用颜色的Handler
class ColorHandler(logging.StreamHandler):
def __init__(self, stream=None, level=logging.NOTSET):
super().__init__(stream=stream)
self.level = level
def emit(self, record):
if record.levelno >= self.level:
if record.levelno >= logging.ERROR:
color = Fore.RED # 红色
elif record.levelno >= logging.WARNING:
color = Fore.YELLOW # 黄色
elif record.levelno >= logging.INFO:
color = Fore.GREEN # 绿色
else:
color = Style.RESET_ALL # 默认颜色
message = self.format(record)
message = color + message + Style.RESET_ALL # 恢复默认颜色
stream = self.stream
stream.write(message)
stream.write(self.terminator)
# 创建ColorHandler对象，并添加到Logger中
handler = ColorHandler(level=level)
logger.addHandler(handler)
return logger
if __name__ == '__main__':
logger = get_logger(logging.DEBUG)
# 输出不同级别的日志
logger.debug("debug message")
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
| 1,613 | Python | .py | 40 | 27.575 | 69 | 0.595451 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,562 | logging_with_color01.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/BBB_Backup/logging_with_color/logging_with_color01.py | import logging
import sys
# 定义一个输出到终端并使用颜色的Handler
class ColorHandler(logging.StreamHandler):
def emit(self, record):
if record.levelno >= logging.ERROR:
color = '\033[31m' # 红色
elif record.levelno >= logging.WARNING:
color = '\033[33m' # 黄色
elif record.levelno >= logging.INFO:
color = '\033[32m' # 绿色
else:
color = '\033[0m' # 默认颜色
message = self.format(record)
message = color + message + '\033[0m' # 恢复默认颜色
stream = self.stream
stream.write(message)
stream.write(self.terminator)
# 创建Logger对象，并添加ColorHandler
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = ColorHandler(sys.stdout)
logger.addHandler(handler)
# 输出不同级别的日志
logger.debug("debug message")
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
| 1,033 | Python | .py | 29 | 26.931034 | 55 | 0.672928 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,563 | voc_label_2.0.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/train_utils/voc_label_2.0.py | # xml解析包
import xml.etree.ElementTree as ET
import pickle
import os
# os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
from os import listdir, getcwd
from os.path import join
# 此目录结构适合yolov5-4.0及以上版本
# ROOT
# └──dataset
# ├──Annotations
# ├──images
# ├──imageSets
# └──labels
sets = ['train', 'test', 'val']
classes = ['Bottle', 'Cloth', 'Kitchen Waste', 'Metal', 'Paper', 'Plastic']
# 进行归一化操作
def convert(size, box): # size:(原图w,原图h) , box:(xmin,xmax,ymin,ymax)
dw = 1./size[0] # 1/w
dh = 1./size[1] # 1/h
x = (box[0] + box[1])/2.0 # 物体在图中的中心点x坐标
y = (box[2] + box[3])/2.0 # 物体在图中的中心点y坐标
w = box[1] - box[0] # 物体实际像素宽度
h = box[3] - box[2] # 物体实际像素高度
x = x*dw # 物体中心点x的坐标比(相当于 x/原图w)
w = w*dw # 物体宽度的宽度比(相当于 w/原图w)
y = y*dh # 物体中心点y的坐标比(相当于 y/原图h)
h = h*dh # 物体宽度的宽度比(相当于 h/原图h)
return (x, y, w, h) # 返回 相对于原图的物体中心点的x坐标比,y坐标比,宽度比,高度比,取值范围[0-1]
# year ='2012', 对应图片的id（文件名）
def convert_annotation(image_id):
'''
将对应文件名的xml文件转化为label文件，xml文件包含了对应的bunding框以及图片长款大小等信息，
通过对其解析，然后进行归一化最终读到label文件中去，也就是说
一张图片文件对应一个xml文件，然后通过解析和归一化，能够将对应的信息保存到唯一一个label文件中去
labal文件中的格式：calss x y w h 同时，一张图片对应的类别有多个，所以对应的ｂｕｎｄｉｎｇ的信息也有多个
'''
# 对应的通过year 找到相应的文件夹，并且打开相应image_id的xml文件，其对应bund文件
in_file = open('dataset/Annotations/%s.xml' % (image_id), encoding='utf-8')
# 准备在对应的image_id 中写入对应的label，分别为
# <object-class> <x> <y> <width> <height>
out_file = open('dataset/labels/%s.txt' % (image_id), 'w', encoding='utf-8')
# 解析xml文件
tree = ET.parse(in_file)
# 获得对应的键值对
root = tree.getroot()
# 获得图片的尺寸大小
size = root.find('size')
# 如果xml内的标记为空，增加判断条件
if size != None:
# 获得宽
w = int(size.find('width').text)
# 获得高
h = int(size.find('height').text)
# 遍历目标obj
for obj in root.iter('object'):
# 获得difficult ？？
difficult = obj.find('difficult').text
# 获得类别 =string 类型
cls = obj.find('name').text
# 如果类别不是对应在我们预定好的class文件中，或difficult==1则跳过
if cls not in classes or int(difficult) == 1:
continue
# 通过类别名称找到id
cls_id = classes.index(cls)
# 找到bndbox 对象
xmlbox = obj.find('bndbox')
# 获取对应的bndbox的数组 = ['xmin','xmax','ymin','ymax']
b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
float(xmlbox.find('ymax').text))
print(image_id, cls, b)
# 带入进行归一化操作
# w = 宽, h = 高， b= bndbox的数组 = ['xmin','xmax','ymin','ymax']
bb = convert((w, h), b)
# bb 对应的是归一化后的(x,y,w,h)
# 生成 calss x y w h 在label文件中
out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
# 返回当前工作目录
wd = getcwd()
print(wd)
for image_set in sets:
'''
对所有的文件数据集进行遍历
做了两个工作：
１．将所有图片文件都遍历一遍，并且将其所有的全路径都写在对应的txt文件中去，方便定位
２．同时对所有的图片文件进行解析和转化，将其对应的bundingbox 以及类别的信息全部解析写到label 文件中去
最后再通过直接读取文件，就能找到对应的label 信息
'''
# 先找labels文件夹如果不存在则创建
if not os.path.exists('dataset/labels/'):
os.makedirs('dataset/labels/')
# 读取在ImageSets/Main 中的train、test..等文件的内容
# 包含对应的文件名称
image_ids = open('dataset/ImageSets/%s.txt' % (image_set)).read().strip().split()
# 打开对应的2012_train.txt 文件对其进行写入准备
list_file = open('dataset/%s.txt' % (image_set), 'w')
# 将对应的文件_id以及全路径写进去并换行
for image_id in image_ids:
list_file.write('dataset/images/%s.jpg\n' % (image_id))
# 调用 year = 年份 image_id = 对应的文件名_id
convert_annotation(image_id)
# 关闭文件
list_file.close()
# os.system(‘comand’) 会执行括号中的命令，如果命令成功执行，这条语句返回0，否则返回1
# os.system("cat 2007_train.txt 2007_val.txt 2012_train.txt 2012_val.txt > train.txt")
# os.system("cat 2007_train.txt 2007_val.txt 2007_test.txt 2012_train.txt 2012_val.txt > train.all.txt")
| 5,521 | Python | .py | 106 | 31.188679 | 115 | 0.608221 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,564 | makeTxt_2.0.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/train_utils/makeTxt_2.0.py | import os
import random
'''
此目录结构适合yolov5-4.0及以上版本
ROOT
└──dataset
├──Annotations
├──images
├──imageSets
└──labels
'''
trainval_percent = 0.9
train_percent = 0.9
xmlfilepath = 'dataset/Annotations'
txtsavepath = 'dataset/ImageSets'
total_xml = os.listdir(xmlfilepath)
num = len(total_xml)
list = range(num)
tv = int(num * trainval_percent)
tr = int(tv * train_percent)
trainval = random.sample(list, tv)
train = random.sample(trainval, tr)
ftrainval = open('dataset/ImageSets/trainval.txt', 'w')
ftest = open('dataset/ImageSets/test.txt', 'w')
ftrain = open('dataset/ImageSets/train.txt', 'w')
fval = open('dataset/ImageSets/val.txt', 'w')
for i in list:
name = total_xml[i][:-4] + '\n'
if i in trainval:
ftrainval.write(name)
if i in train:
ftrain.write(name)
else:
fval.write(name)
else:
ftest.write(name)
ftrainval.close()
ftrain.close()
fval.close()
ftest.close()
| 1,012 | Python | .py | 40 | 20.7 | 55 | 0.678728 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,565 | predict.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/classify/predict.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Run classification inference on images
Usage:
$ python classify/predict.py --weights yolov5s-cls.pt --source im.jpg
"""
import argparse
import os
import sys
from pathlib import Path
import cv2
import torch.nn.functional as F
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from classify.train import imshow_cls
from models.common import DetectMultiBackend
from utils.augmentations import classify_transforms
from utils.general import LOGGER, check_requirements, colorstr, increment_path, print_args
from utils.torch_utils import select_device, smart_inference_mode, time_sync
@smart_inference_mode()
def run(
weights=ROOT / 'yolov5s-cls.pt', # model.pt path(s)
source=ROOT / 'data/images/bus.jpg', # file/dir/URL/glob, 0 for webcam
imgsz=224, # inference size
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
half=False, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
show=True,
project=ROOT / 'runs/predict-cls', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
):
file = str(source)
seen, dt = 1, [0.0, 0.0, 0.0]
device = select_device(device)
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
save_dir.mkdir(parents=True, exist_ok=True) # make dir
# Transforms
transforms = classify_transforms(imgsz)
# Load model
model = DetectMultiBackend(weights, device=device, dnn=dnn, fp16=half)
model.warmup(imgsz=(1, 3, imgsz, imgsz)) # warmup
# Image
t1 = time_sync()
im = cv2.cvtColor(cv2.imread(file), cv2.COLOR_BGR2RGB)
im = transforms(im).unsqueeze(0).to(device)
im = im.half() if model.fp16 else im.float()
t2 = time_sync()
dt[0] += t2 - t1
# Inference
results = model(im)
t3 = time_sync()
dt[1] += t3 - t2
p = F.softmax(results, dim=1) # probabilities
i = p.argsort(1, descending=True)[:, :5].squeeze() # top 5 indices
dt[2] += time_sync() - t3
LOGGER.info(f"image 1/1 {file}: {imgsz}x{imgsz} {', '.join(f'{model.names[j]} {p[0, j]:.2f}' for j in i)}")
# Print results
t = tuple(x / seen * 1E3 for x in dt) # speeds per image
shape = (1, 3, imgsz, imgsz)
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms post-process per image at shape {shape}' % t)
if show:
imshow_cls(im, f=save_dir / Path(file).name, verbose=True)
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}")
return p
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s-cls.pt', help='model path(s)')
parser.add_argument('--source', type=str, default=ROOT / 'data/images/bus.jpg', help='file')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=224, help='train, val image size (pixels)')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
parser.add_argument('--project', default=ROOT / 'runs/predict-cls', help='save to project/name')
parser.add_argument('--name', default='exp', help='save to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
opt = parser.parse_args()
print_args(vars(opt))
return opt
def main(opt):
check_requirements(exclude=('tensorboard', 'thop'))
run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 4,031 | Python | .py | 89 | 40.741573 | 119 | 0.668536 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,566 | val.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/classify/val.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Validate a classification model on a dataset
Usage:
$ python classify/val.py --weights yolov5s-cls.pt --data ../datasets/imagenet
"""
import argparse
import os
import sys
from pathlib import Path
import torch
from tqdm import tqdm
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from models.common import DetectMultiBackend
from utils.dataloaders import create_classification_dataloader
from utils.general import LOGGER, check_img_size, check_requirements, colorstr, increment_path, print_args
from utils.torch_utils import select_device, smart_inference_mode, time_sync
@smart_inference_mode()
def run(
data=ROOT / '../datasets/mnist', # dataset dir
weights=ROOT / 'yolov5s-cls.pt', # model.pt path(s)
batch_size=128, # batch size
imgsz=224, # inference size (pixels)
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
workers=8, # max dataloader workers (per RANK in DDP mode)
verbose=False, # verbose output
project=ROOT / 'runs/val-cls', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
half=True, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
model=None,
dataloader=None,
criterion=None,
pbar=None,
):
# Initialize/load model and set device
training = model is not None
if training: # called by train.py
device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model
half &= device.type != 'cpu' # half precision only supported on CUDA
model.half() if half else model.float()
else: # called directly
device = select_device(device, batch_size=batch_size)
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
save_dir.mkdir(parents=True, exist_ok=True) # make dir
# Load model
model = DetectMultiBackend(weights, device=device, dnn=dnn, fp16=half)
stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
half = model.fp16 # FP16 supported on limited backends with CUDA
if engine:
batch_size = model.batch_size
else:
device = model.device
if not (pt or jit):
batch_size = 1 # export.py models default to batch-size 1
LOGGER.info(f'Forcing --batch-size 1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models')
# Dataloader
data = Path(data)
test_dir = data / 'test' if (data / 'test').exists() else data / 'val' # data/test or data/val
dataloader = create_classification_dataloader(path=test_dir,
imgsz=imgsz,
batch_size=batch_size,
augment=False,
rank=-1,
workers=workers)
model.eval()
pred, targets, loss, dt = [], [], 0, [0.0, 0.0, 0.0]
n = len(dataloader) # number of batches
action = 'validating' if dataloader.dataset.root.stem == 'val' else 'testing'
desc = f"{pbar.desc[:-36]}{action:>36}" if pbar else f"{action}"
bar = tqdm(dataloader, desc, n, not training, bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}', position=0)
with torch.cuda.amp.autocast(enabled=device.type != 'cpu'):
for images, labels in bar:
t1 = time_sync()
images, labels = images.to(device, non_blocking=True), labels.to(device)
t2 = time_sync()
dt[0] += t2 - t1
y = model(images)
t3 = time_sync()
dt[1] += t3 - t2
pred.append(y.argsort(1, descending=True)[:, :5])
targets.append(labels)
if criterion:
loss += criterion(y, labels)
dt[2] += time_sync() - t3
loss /= n
pred, targets = torch.cat(pred), torch.cat(targets)
correct = (targets[:, None] == pred).float()
acc = torch.stack((correct[:, 0], correct.max(1).values), dim=1) # (top1, top5) accuracy
top1, top5 = acc.mean(0).tolist()
if pbar:
pbar.desc = f"{pbar.desc[:-36]}{loss:>12.3g}{top1:>12.3g}{top5:>12.3g}"
if verbose: # all classes
LOGGER.info(f"{'Class':>24}{'Images':>12}{'top1_acc':>12}{'top5_acc':>12}")
LOGGER.info(f"{'all':>24}{targets.shape[0]:>12}{top1:>12.3g}{top5:>12.3g}")
for i, c in enumerate(model.names):
aci = acc[targets == i]
top1i, top5i = aci.mean(0).tolist()
LOGGER.info(f"{c:>24}{aci.shape[0]:>12}{top1i:>12.3g}{top5i:>12.3g}")
# Print results
t = tuple(x / len(dataloader.dataset.samples) * 1E3 for x in dt) # speeds per image
shape = (1, 3, imgsz, imgsz)
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms post-process per image at shape {shape}' % t)
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}")
return top1, top5, loss
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--data', type=str, default=ROOT / '../datasets/mnist', help='dataset path')
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s-cls.pt', help='model.pt path(s)')
parser.add_argument('--batch-size', type=int, default=128, help='batch size')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=224, help='inference size (pixels)')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
parser.add_argument('--verbose', nargs='?', const=True, default=True, help='verbose output')
parser.add_argument('--project', default=ROOT / 'runs/val-cls', help='save to project/name')
parser.add_argument('--name', default='exp', help='save to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
opt = parser.parse_args()
print_args(vars(opt))
return opt
def main(opt):
check_requirements(exclude=('tensorboard', 'thop'))
run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 6,938 | Python | .py | 135 | 43.007407 | 120 | 0.617847 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,567 | train.py | FlatWhite233_yolov5_garbage_detect/yolov5_garbage_detect-backend/classify/train.py | # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Train a YOLOv5 classifier model on a classification dataset
Datasets: --data mnist, fashion-mnist, cifar10, cifar100, imagenette, imagewoof, imagenet, or 'path/to/custom/dataset'
Usage:
$ python classify/train.py --model yolov5s-cls.pt --data cifar100 --epochs 5 --img 128
$ python -m torch.distributed.run --nproc_per_node 4 --master_port 1 classify/train.py --model yolov5s-cls.pt --data imagenet --epochs 5 --img 224 --device 0,1,2,3
"""
import argparse
import os
import subprocess
import sys
import time
from copy import deepcopy
from datetime import datetime
from pathlib import Path
import torch
import torch.distributed as dist
import torch.hub as hub
import torch.optim.lr_scheduler as lr_scheduler
import torchvision
from torch.cuda import amp
from tqdm import tqdm
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from classify import val as validate
from models.experimental import attempt_load
from models.yolo import ClassificationModel, DetectionModel
from utils.dataloaders import create_classification_dataloader
from utils.general import (DATASETS_DIR, LOGGER, WorkingDirectory, check_git_status, check_requirements, colorstr,
download, increment_path, init_seeds, print_args, yaml_save)
from utils.loggers import GenericLogger
from utils.plots import imshow_cls
from utils.torch_utils import (ModelEMA, model_info, reshape_classifier_output, select_device, smart_DDP,
smart_optimizer, smartCrossEntropyLoss, torch_distributed_zero_first)
LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1)) # https://pytorch.org/docs/stable/elastic/run.html
RANK = int(os.getenv('RANK', -1))
WORLD_SIZE = int(os.getenv('WORLD_SIZE', 1))
def train(opt, device):
init_seeds(opt.seed + 1 + RANK, deterministic=True)
save_dir, data, bs, epochs, nw, imgsz, pretrained = \
opt.save_dir, Path(opt.data), opt.batch_size, opt.epochs, min(os.cpu_count() - 1, opt.workers), \
opt.imgsz, str(opt.pretrained).lower() == 'true'
cuda = device.type != 'cpu'
# Directories
wdir = save_dir / 'weights'
wdir.mkdir(parents=True, exist_ok=True) # make dir
last, best = wdir / 'last.pt', wdir / 'best.pt'
# Save run settings
yaml_save(save_dir / 'opt.yaml', vars(opt))
# Logger
logger = GenericLogger(opt=opt, console_logger=LOGGER) if RANK in {-1, 0} else None
# Download Dataset
with torch_distributed_zero_first(LOCAL_RANK), WorkingDirectory(ROOT):
data_dir = data if data.is_dir() else (DATASETS_DIR / data)
if not data_dir.is_dir():
LOGGER.info(f'\nDataset not found ⚠�, missing path {data_dir}, attempting download...')
t = time.time()
if str(data) == 'imagenet':
subprocess.run(f"bash {ROOT / 'data/scripts/get_imagenet.sh'}", shell=True, check=True)
else:
url = f'https://github.com/ultralytics/yolov5/releases/download/v1.0/{data}.zip'
download(url, dir=data_dir.parent)
s = f"Dataset download success ✅ ({time.time() - t:.1f}s), saved to {colorstr('bold', data_dir)}\n"
LOGGER.info(s)
# Dataloaders
nc = len([x for x in (data_dir / 'train').glob('*') if x.is_dir()]) # number of classes
trainloader = create_classification_dataloader(path=data_dir / 'train',
imgsz=imgsz,
batch_size=bs // WORLD_SIZE,
augment=True,
cache=opt.cache,
rank=LOCAL_RANK,
workers=nw)
test_dir = data_dir / 'test' if (data_dir / 'test').exists() else data_dir / 'val' # data/test or data/val
if RANK in {-1, 0}:
testloader = create_classification_dataloader(path=test_dir,
imgsz=imgsz,
batch_size=bs // WORLD_SIZE * 2,
augment=False,
cache=opt.cache,
rank=-1,
workers=nw)
# Model
with torch_distributed_zero_first(LOCAL_RANK), WorkingDirectory(ROOT):
if Path(opt.model).is_file() or opt.model.endswith('.pt'):
model = attempt_load(opt.model, device='cpu', fuse=False)
elif opt.model in torchvision.models.__dict__: # TorchVision models i.e. resnet50, efficientnet_b0
model = torchvision.models.__dict__[opt.model](weights='IMAGENET1K_V1' if pretrained else None)
else:
m = hub.list('ultralytics/yolov5') # + hub.list('pytorch/vision') # models
raise ModuleNotFoundError(f'--model {opt.model} not found. Available models are: \n' + '\n'.join(m))
if isinstance(model, DetectionModel):
LOGGER.warning("WARNING: pass YOLOv5 classifier model with '-cls' suffix, i.e. '--model yolov5s-cls.pt'")
model = ClassificationModel(model=model, nc=nc, cutoff=opt.cutoff or 10) # convert to classification model
reshape_classifier_output(model, nc) # update class count
for p in model.parameters():
p.requires_grad = True # for training
for m in model.modules():
if not pretrained and hasattr(m, 'reset_parameters'):
m.reset_parameters()
if isinstance(m, torch.nn.Dropout) and opt.dropout is not None:
m.p = opt.dropout # set dropout
model = model.to(device)
names = trainloader.dataset.classes # class names
model.names = names # attach class names
# Info
if RANK in {-1, 0}:
model_info(model)
if opt.verbose:
LOGGER.info(model)
images, labels = next(iter(trainloader))
file = imshow_cls(images[:25], labels[:25], names=names, f=save_dir / 'train_images.jpg')
logger.log_images(file, name='Train Examples')
logger.log_graph(model, imgsz) # log model
# Optimizer
optimizer = smart_optimizer(model, opt.optimizer, opt.lr0, momentum=0.9, decay=5e-5)
# Scheduler
lrf = 0.01 # final lr (fraction of lr0)
# lf = lambda x: ((1 + math.cos(x * math.pi / epochs)) / 2) * (1 - lrf) + lrf # cosine
lf = lambda x: (1 - x / epochs) * (1 - lrf) + lrf # linear
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)
# scheduler = lr_scheduler.OneCycleLR(optimizer, max_lr=lr0, total_steps=epochs, pct_start=0.1,
# final_div_factor=1 / 25 / lrf)
# EMA
ema = ModelEMA(model) if RANK in {-1, 0} else None
# DDP mode
if cuda and RANK != -1:
model = smart_DDP(model)
# Train
t0 = time.time()
criterion = smartCrossEntropyLoss(label_smoothing=opt.label_smoothing) # loss function
best_fitness = 0.0
scaler = amp.GradScaler(enabled=cuda)
val = test_dir.stem # 'val' or 'test'
LOGGER.info(f'Image sizes {imgsz} train, {imgsz} test\n'
f'Using {nw * WORLD_SIZE} dataloader workers\n'
f"Logging results to {colorstr('bold', save_dir)}\n"
f'Starting {opt.model} training on {data} dataset with {nc} classes for {epochs} epochs...\n\n'
f"{'Epoch':>10}{'GPU_mem':>10}{'train_loss':>12}{f'{val}_loss':>12}{'top1_acc':>12}{'top5_acc':>12}")
for epoch in range(epochs): # loop over the dataset multiple times
tloss, vloss, fitness = 0.0, 0.0, 0.0 # train loss, val loss, fitness
model.train()
if RANK != -1:
trainloader.sampler.set_epoch(epoch)
pbar = enumerate(trainloader)
if RANK in {-1, 0}:
pbar = tqdm(enumerate(trainloader), total=len(trainloader), bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}')
for i, (images, labels) in pbar: # progress bar
images, labels = images.to(device, non_blocking=True), labels.to(device)
# Forward
with amp.autocast(enabled=cuda): # stability issues when enabled
loss = criterion(model(images), labels)
# Backward
scaler.scale(loss).backward()
# Optimize
scaler.unscale_(optimizer) # unscale gradients
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=10.0) # clip gradients
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()
if ema:
ema.update(model)
if RANK in {-1, 0}:
# Print
tloss = (tloss * i + loss.item()) / (i + 1) # update mean losses
mem = '%.3gG' % (torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0) # (GB)
pbar.desc = f"{f'{epoch + 1}/{epochs}':>10}{mem:>10}{tloss:>12.3g}" + ' ' * 36
# Test
if i == len(pbar) - 1: # last batch
top1, top5, vloss = validate.run(model=ema.ema,
dataloader=testloader,
criterion=criterion,
pbar=pbar) # test accuracy, loss
fitness = top1 # define fitness as top1 accuracy
# Scheduler
scheduler.step()
# Log metrics
if RANK in {-1, 0}:
# Best fitness
if fitness > best_fitness:
best_fitness = fitness
# Log
metrics = {
"train/loss": tloss,
f"{val}/loss": vloss,
"metrics/accuracy_top1": top1,
"metrics/accuracy_top5": top5,
"lr/0": optimizer.param_groups[0]['lr']} # learning rate
logger.log_metrics(metrics, epoch)
# Save model
final_epoch = epoch + 1 == epochs
if (not opt.nosave) or final_epoch:
ckpt = {
'epoch': epoch,
'best_fitness': best_fitness,
'model': deepcopy(ema.ema).half(), # deepcopy(de_parallel(model)).half(),
'ema': None, # deepcopy(ema.ema).half(),
'updates': ema.updates,
'optimizer': None, # optimizer.state_dict(),
'opt': vars(opt),
'date': datetime.now().isoformat()}
# Save last, best and delete
torch.save(ckpt, last)
if best_fitness == fitness:
torch.save(ckpt, best)
del ckpt
# Train complete
if RANK in {-1, 0} and final_epoch:
LOGGER.info(f'\nTraining complete ({(time.time() - t0) / 3600:.3f} hours)'
f"\nResults saved to {colorstr('bold', save_dir)}"
f"\nPredict: python classify/predict.py --weights {best} --source im.jpg"
f"\nValidate: python classify/val.py --weights {best} --data {data_dir}"
f"\nExport: python export.py --weights {best} --include onnx"
f"\nPyTorch Hub: model = torch.hub.load('ultralytics/yolov5', 'custom', '{best}')"
f"\nVisualize: https://netron.app\n")
# Plot examples
images, labels = (x[:25] for x in next(iter(testloader))) # first 25 images and labels
pred = torch.max(ema.ema((images.half() if cuda else images.float()).to(device)), 1)[1]
file = imshow_cls(images, labels, pred, names, verbose=False, f=save_dir / 'test_images.jpg')
# Log results
meta = {"epochs": epochs, "top1_acc": best_fitness, "date": datetime.now().isoformat()}
logger.log_images(file, name='Test Examples (true-predicted)', epoch=epoch)
logger.log_model(best, epochs, metadata=meta)
def parse_opt(known=False):
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, default='yolov5s-cls.pt', help='initial weights path')
parser.add_argument('--data', type=str, default='mnist', help='cifar10, cifar100, mnist, imagenet, etc.')
parser.add_argument('--epochs', type=int, default=10)
parser.add_argument('--batch-size', type=int, default=64, help='total batch size for all GPUs')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=128, help='train, val image size (pixels)')
parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
parser.add_argument('--cache', type=str, nargs='?', const='ram', help='--cache images in "ram" (default) or "disk"')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
parser.add_argument('--project', default=ROOT / 'runs/train-cls', help='save to project/name')
parser.add_argument('--name', default='exp', help='save to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
parser.add_argument('--pretrained', nargs='?', const=True, default=True, help='start from i.e. --pretrained False')
parser.add_argument('--optimizer', choices=['SGD', 'Adam', 'AdamW', 'RMSProp'], default='Adam', help='optimizer')
parser.add_argument('--lr0', type=float, default=0.001, help='initial learning rate')
parser.add_argument('--label-smoothing', type=float, default=0.1, help='Label smoothing epsilon')
parser.add_argument('--cutoff', type=int, default=None, help='Model layer cutoff index for Classify() head')
parser.add_argument('--dropout', type=float, default=None, help='Dropout (fraction)')
parser.add_argument('--verbose', action='store_true', help='Verbose mode')
parser.add_argument('--seed', type=int, default=0, help='Global training seed')
parser.add_argument('--local_rank', type=int, default=-1, help='Automatic DDP Multi-GPU argument, do not modify')
return parser.parse_known_args()[0] if known else parser.parse_args()
def main(opt):
# Checks
if RANK in {-1, 0}:
print_args(vars(opt))
check_git_status()
check_requirements()
# DDP mode
device = select_device(opt.device, batch_size=opt.batch_size)
if LOCAL_RANK != -1:
assert opt.batch_size != -1, 'AutoBatch is coming soon for classification, please pass a valid --batch-size'
assert opt.batch_size % WORLD_SIZE == 0, f'--batch-size {opt.batch_size} must be multiple of WORLD_SIZE'
assert torch.cuda.device_count() > LOCAL_RANK, 'insufficient CUDA devices for DDP command'
torch.cuda.set_device(LOCAL_RANK)
device = torch.device('cuda', LOCAL_RANK)
dist.init_process_group(backend="nccl" if dist.is_nccl_available() else "gloo")
# Parameters
opt.save_dir = increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok) # increment run
# Train
train(opt, device)
def run(**kwargs):
# Usage: from yolov5 import classify; classify.train.run(data=mnist, imgsz=320, model='yolov5m')
opt = parse_opt(True)
for k, v in kwargs.items():
setattr(opt, k, v)
main(opt)
return opt
if __name__ == "__main__":
opt = parse_opt()
main(opt)
| 15,766 | Python | .py | 280 | 45.078571 | 167 | 0.59491 | FlatWhite233/yolov5_garbage_detect | 8 | 1 | 0 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,568 | setup.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/setup.py | # SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import io
import os
import re
import sys
try:
from setuptools import find_packages, setup
except ImportError:
print(
"Package setuptools is missing from your Python installation. "
"Please see the installation section in the esptool documentation"
" for instructions on how to install it."
)
exit(1)
# Example code to pull version from esptool module with regex, taken from
# https://packaging.python.org/en/latest/guides/single-sourcing-package-version/
def read(*names, **kwargs):
with io.open(
os.path.join(os.path.dirname(__file__), *names),
encoding=kwargs.get("encoding", "utf8"),
) as fp:
return fp.read()
def find_version(*file_paths):
version_file = read(*file_paths)
version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M)
if version_match:
return version_match.group(1)
raise RuntimeError("Unable to find version string.")
if os.name != "nt":
scripts = ["esptool.py", "espefuse.py", "espsecure.py", "esp_rfc2217_server.py"]
entry_points = {}
else:
scripts = []
entry_points = {
"console_scripts": [
"esptool.py=esptool.__init__:_main",
"espsecure.py=espsecure.__init__:_main",
"espefuse.py=espefuse.__init__:_main",
"esp_rfc2217_server.py=esp_rfc2217_server:main",
],
}
long_description = """
==========
esptool.py
==========
A Python-based, open-source, platform-independent utility to communicate with \
the ROM bootloader in Espressif chips.
The esptool.py project is `hosted on github <https://github.com/espressif/esptool>`_.
Documentation
-------------
Visit online `esptool documentation <https://docs.espressif.com/projects/esptool/>`_ \
or run ``esptool.py -h``.
Contributing
------------
Please see the `contributions guide \
<https://docs.espressif.com/projects/esptool/en/latest/contributing.html>`_.
"""
setup(
name="esptool",
version=find_version("esptool/__init__.py"),
description="A serial utility to communicate & flash code to Espressif chips.",
long_description=long_description,
url="https://github.com/espressif/esptool/",
project_urls={
"Documentation": "https://docs.espressif.com/projects/esptool/",
"Source": "https://github.com/espressif/esptool/",
"Tracker": "https://github.com/espressif/esptool/issues/",
},
author="Fredrik Ahlberg (themadinventor) & Angus Gratton (projectgus) "
"& Espressif Systems",
author_email="",
license="GPLv2+",
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Natural Language :: English",
"Operating System :: POSIX",
"Operating System :: Microsoft :: Windows",
"Operating System :: MacOS :: MacOS X",
"Topic :: Software Development :: Embedded Systems",
"Environment :: Console",
"License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
],
python_requires=">=3.7",
setup_requires=(["wheel"] if "bdist_wheel" in sys.argv else []),
extras_require={
"dev": [
"flake8>=3.2.0",
"flake8-import-order",
"flake8-gl-codeclimate",
"pyelftools",
"coverage~=6.0",
"black",
"pre-commit",
"pytest",
"pytest-rerunfailures",
],
"hsm": [
"python-pkcs11",
],
},
install_requires=[
"bitstring>=3.1.6",
"cryptography>=2.1.4",
"ecdsa>=0.16.0",
"pyserial>=3.0",
"reedsolo>=1.5.3,<1.8",
"PyYAML>=5.1",
],
packages=find_packages(),
include_package_data=True,
package_data={"": ["esptool/targets/stub_flasher/*.json"]},
entry_points=entry_points,
scripts=scripts,
)
| 4,274 | Python | .py | 122 | 28.967213 | 88 | 0.623731 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,569 | espefuse.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espefuse.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
# This executable script is a thin wrapper around the main functionality
# in the espefuse Python package
# When updating this script, please also update esptool.py and espsecure.py
import contextlib
import os
import sys
if os.name != "nt":
# Linux/macOS: remove current script directory to avoid importing this file
# as a module; we want to import the installed espefuse module instead
with contextlib.suppress(ValueError):
executable_dir = os.path.dirname(sys.executable)
sys.path = [
path
for path in sys.path
if not path.endswith(("/bin", "/sbin")) and path != executable_dir
]
# Linux/macOS: delete imported module entry to force Python to load
# the module from scratch; this enables importing espefuse module in
# other Python scripts
with contextlib.suppress(KeyError):
del sys.modules["espefuse"]
import espefuse
if __name__ == "__main__":
espefuse._main()
| 1,180 | Python | .py | 30 | 34.766667 | 79 | 0.718285 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,570 | esptool.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
# This executable script is a thin wrapper around the main functionality
# in the esptool Python package
# When updating this script, please also update espefuse.py and espsecure.py
import contextlib
import os
import sys
if os.name != "nt":
# Linux/macOS: remove current script directory to avoid importing this file
# as a module; we want to import the installed esptool module instead
with contextlib.suppress(ValueError):
executable_dir = os.path.dirname(sys.executable)
sys.path = [
path
for path in sys.path
if not path.endswith(("/bin", "/sbin")) and path != executable_dir
]
# Linux/macOS: delete imported module entry to force Python to load
# the module from scratch; this enables importing esptool module in
# other Python scripts
with contextlib.suppress(KeyError):
del sys.modules["esptool"]
import esptool
if __name__ == "__main__":
esptool._main()
| 1,175 | Python | .py | 30 | 34.6 | 79 | 0.717047 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,571 | esp_rfc2217_server.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esp_rfc2217_server.py | #!/usr/bin/env python
# SPDX-FileCopyrightText: 2009-2015 Chris Liechti
# SPDX-FileContributor: 2020-2022 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: BSD-3-Clause
#
# Redirect data from a TCP/IP connection to a serial port and vice versa using RFC 2217.
#
# This is a modified version of rfc2217_server.py provided by the pyserial package
# (pythonhosted.org/pyserial/examples.html#single-port-tcp-ip-serial-bridge-rfc-2217).
# It uses a custom PortManager to properly apply the RTS & DTR signals
# for reseting ESP chips.
#
# Run the following command on the server side to make
# connection between /dev/ttyUSB1 and TCP port 4000:
#
# python esp_rfc2217_server.py -p 4000 /dev/ttyUSB1
#
# Esptool can connect to the ESP device through that server as it is
# demonstrated in the following example:
#
# esptool.py --port rfc2217://localhost:4000?ign_set_control flash_id
#
###################################################################################
# redirect data from a TCP/IP connection to a serial port and vice versa
# using RFC 2217
#
# (C) 2009-2015 Chris Liechti <[email protected]>
#
# SPDX-License-Identifier: BSD-3-Clause
import logging
import os
import socket
import sys
import threading
import time
from esptool.config import load_config_file
from esptool.reset import ClassicReset, CustomReset, DEFAULT_RESET_DELAY, UnixTightReset
import serial
import serial.rfc2217
from serial.rfc2217 import (
COM_PORT_OPTION,
SET_CONTROL,
SET_CONTROL_DTR_OFF,
SET_CONTROL_DTR_ON,
SET_CONTROL_RTS_OFF,
SET_CONTROL_RTS_ON,
)
cfg, _ = load_config_file(verbose=True)
cfg = cfg["esptool"]
class EspPortManager(serial.rfc2217.PortManager):
"""
The beginning of the reset sequence is detected and the proper reset sequence
is applied in a thread. The rest of the reset sequence received is just ignored
and not sent to the serial port.
"""
def __init__(self, serial_port, connection, esp32r0_delay, logger=None):
self.esp32r0_delay = esp32r0_delay
super(EspPortManager, self).__init__(serial_port, connection, logger)
def _telnet_process_subnegotiation(self, suboption):
if suboption[0:1] == COM_PORT_OPTION and suboption[1:2] == SET_CONTROL:
if suboption[2:3] == SET_CONTROL_DTR_OFF:
self.serial.dtr = False
return
elif suboption[2:3] == SET_CONTROL_RTS_ON and not self.serial.dtr:
reset_thread = threading.Thread(target=self._reset_thread)
reset_thread.daemon = True
reset_thread.name = "reset_thread"
reset_thread.start()
return
elif suboption[2:3] in [
SET_CONTROL_DTR_ON,
SET_CONTROL_RTS_ON,
SET_CONTROL_RTS_OFF,
]:
return
# only in cases not handled above do the original implementation in PortManager
super(EspPortManager, self)._telnet_process_subnegotiation(suboption)
def _reset_thread(self):
"""
The reset logic is used from esptool.py because the RTS and DTR signals
cannot be retransmitted through RFC 2217 with proper timing.
"""
if self.logger:
self.logger.info("Activating reset in thread")
delay = DEFAULT_RESET_DELAY
if self.esp32r0_delay:
delay += 0.5
cfg_custom_reset_sequence = cfg.get("custom_reset_sequence")
if cfg_custom_reset_sequence is not None:
CustomReset(self.serial, cfg_custom_reset_sequence)()
elif os.name != "nt":
UnixTightReset(self.serial, delay)()
else:
ClassicReset(self.serial, delay)()
class Redirector(object):
def __init__(self, serial_instance, socket, debug=False, esp32r0delay=False):
self.serial = serial_instance
self.socket = socket
self._write_lock = threading.Lock()
self.rfc2217 = EspPortManager(
self.serial,
self,
esp32r0delay,
logger=logging.getLogger("rfc2217.server") if debug else None,
)
self.log = logging.getLogger("redirector")
def statusline_poller(self):
self.log.debug("status line poll thread started")
while self.alive:
time.sleep(1)
self.rfc2217.check_modem_lines()
self.log.debug("status line poll thread terminated")
def shortcircuit(self):
"""connect the serial port to the TCP port by copying everything
from one side to the other"""
self.alive = True
self.thread_read = threading.Thread(target=self.reader)
self.thread_read.daemon = True
self.thread_read.name = "serial->socket"
self.thread_read.start()
self.thread_poll = threading.Thread(target=self.statusline_poller)
self.thread_poll.daemon = True
self.thread_poll.name = "status line poll"
self.thread_poll.start()
self.writer()
def reader(self):
"""loop forever and copy serial->socket"""
self.log.debug("reader thread started")
while self.alive:
try:
data = self.serial.read(self.serial.in_waiting or 1)
if data:
# escape outgoing data when needed (Telnet IAC (0xff) character)
self.write(b"".join(self.rfc2217.escape(data)))
except socket.error as msg:
self.log.error("{}".format(msg))
# probably got disconnected
break
self.alive = False
self.log.debug("reader thread terminated")
def write(self, data):
"""thread safe socket write with no data escaping. used to send telnet stuff"""
with self._write_lock:
self.socket.sendall(data)
def writer(self):
"""loop forever and copy socket->serial"""
while self.alive:
try:
data = self.socket.recv(1024)
if not data:
break
self.serial.write(b"".join(self.rfc2217.filter(data)))
except socket.error as msg:
self.log.error("{}".format(msg))
# probably got disconnected
break
self.stop()
def stop(self):
"""Stop copying"""
self.log.debug("stopping")
if self.alive:
self.alive = False
self.thread_read.join()
self.thread_poll.join()
def main():
import argparse
parser = argparse.ArgumentParser(
description="RFC 2217 Serial to Network (TCP/IP) redirector.",
epilog="NOTE: no security measures are implemented. "
"Anyone can remotely connect to this service over the network.\n"
"Only one connection at once is supported. "
"When the connection is terminated it waits for the next connect.",
)
parser.add_argument("SERIALPORT")
parser.add_argument(
"-p",
"--localport",
type=int,
help="local TCP port, default: %(default)s",
metavar="TCPPORT",
default=2217,
)
parser.add_argument(
"-v",
"--verbose",
dest="verbosity",
action="count",
help="print more diagnostic messages (option can be given multiple times)",
default=0,
)
parser.add_argument(
"--r0",
help="Use delays necessary for ESP32 revision 0 chips",
action="store_true",
)
args = parser.parse_args()
if args.verbosity > 3:
args.verbosity = 3
level = (logging.WARNING, logging.INFO, logging.DEBUG, logging.NOTSET)[
args.verbosity
]
logging.basicConfig(level=logging.INFO)
# logging.getLogger('root').setLevel(logging.INFO)
logging.getLogger("rfc2217").setLevel(level)
# connect to serial port
ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True)
ser.timeout = 3 # required so that the reader thread can exit
# reset control line as no _remote_ "terminal" has been connected yet
ser.dtr = False
ser.rts = False
logging.info("RFC 2217 TCP/IP to Serial redirector - type Ctrl-C / BREAK to quit")
try:
ser.open()
except serial.SerialException as e:
logging.error("Could not open serial port {}: {}".format(ser.name, e))
sys.exit(1)
logging.info("Serving serial port: {}".format(ser.name))
settings = ser.get_settings()
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind(("", args.localport))
srv.listen(1)
logging.info("TCP/IP port: {}".format(args.localport))
while True:
try:
client_socket, addr = srv.accept()
logging.info("Connected by {}:{}".format(addr[0], addr[1]))
client_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
ser.rts = True
ser.dtr = True
# enter network <-> serial loop
r = Redirector(ser, client_socket, args.verbosity > 0, args.r0)
try:
r.shortcircuit()
finally:
logging.info("Disconnected")
r.stop()
client_socket.close()
ser.dtr = False
ser.rts = False
# Restore port settings (may have been changed by RFC 2217
# capable client)
ser.apply_settings(settings)
except KeyboardInterrupt:
sys.stdout.write("\n")
break
except socket.error as msg:
logging.error(str(msg))
logging.info("--- exit ---")
if __name__ == "__main__":
main()
| 9,762 | Python | .py | 251 | 30.462151 | 88 | 0.621596 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,572 | espsecure.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espsecure.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
# This executable script is a thin wrapper around the main functionality
# in the espsecure Python package
# When updating this script, please also update esptool.py and espefuse.py
import contextlib
import os
import sys
if os.name != "nt":
# Linux/macOS: remove current script directory to avoid importing this file
# as a module; we want to import the installed espsecure module instead
with contextlib.suppress(ValueError):
executable_dir = os.path.dirname(sys.executable)
sys.path = [
path
for path in sys.path
if not path.endswith(("/bin", "/sbin")) and path != executable_dir
]
# Linux/macOS: delete imported module entry to force Python to load
# the module from scratch; this enables importing espsecure module in
# other Python scripts
with contextlib.suppress(KeyError):
del sys.modules["espsecure"]
import espsecure
if __name__ == "__main__":
espsecure._main()
| 1,185 | Python | .py | 30 | 34.933333 | 79 | 0.719512 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,573 | conftest.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/conftest.py | import pytest
def pytest_addoption(parser):
# test_esptool.py and test_espefuse.py
parser.addoption(
"--port", action="store", default="/dev/ttyUSB0", help="Serial port"
)
parser.addoption("--chip", action="store", default="esp32", help="Chip type")
# test_esptool.py only
parser.addoption("--baud", action="store", default=115200, help="Baud rate")
parser.addoption("--with-trace", action="store_true", default=False, help="Trace")
parser.addoption(
"--preload-port",
action="store",
default=False,
help="Port for dummy binary preloading for USB-JTAG/Serial tests",
)
# test_espefuse.py only
parser.addoption(
"--reset-port", action="store", default=None, help="FPGA reset port"
)
def pytest_configure(config):
# test_esptool.py and test_espefuse.py
global arg_port, arg_chip
arg_port = config.getoption("--port")
arg_chip = config.getoption("--chip")
# test_esptool.py only
global arg_baud, arg_trace, arg_preload_port
arg_baud = config.getoption("--baud")
arg_trace = config.getoption("--with-trace")
arg_preload_port = config.getoption("--preload-port")
# test_espefuse.py only
global arg_reset_port
arg_reset_port = config.getoption("--reset-port")
# register custom markers
config.addinivalue_line(
"markers",
"host_test: mark esptool tests that run on the host machine only "
"(don't require a real chip connected).",
)
config.addinivalue_line(
"markers",
"quick_test: mark esptool tests checking basic functionality.",
)
def need_to_install_package_err():
pytest.exit(
"To run the tests, install esptool in development mode. "
"Instructions: https://docs.espressif.com/projects/esptool/en/latest/"
"contributing.html#development-setup"
)
| 1,894 | Python | .py | 49 | 32.591837 | 86 | 0.665576 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,574 | test_modules.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_modules.py | # Tests for regressions in python modules
# used by esptool.py, espefuse.py, and espsecure.py
import pytest
import reedsolo
@pytest.mark.host_test
def test_reed_solomon_encoding():
# fmt: off
pairs = [("a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", "0404992ae0b12cb0ef0d4fd3"),
("11a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd11bf", "e001803c2130884c190d57d5"),
("22a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd22bf", "6c32056dd3fcc33fa6193773"),
("0a1a2a3a4a5a6a7a8a9aaabacadaeafa0b1b2b3b4b5b6b7b8b9babbbcbdbebfb", "08149eef461af628943c2661"),
("b3f455fb0b275123dec0e73c4becca19246bf2b103df401844a3bdcd3fd01a95", "500409183fa1b8e680568da7"),
("435777773fb1e36f7d6b5f1e99afaa7a57f16be0ed36bc057c7dae6a266d1504", "815d3007153d797bd6630d0e"),
("20a126c10f50ee871f43cfcfe4e62a492e3f729a6c48348a58863f3a482a69fe", "36150928f41dcacf396c0893"),
("a8d5fbda18d75605c422d2b10ac7f73283a5c9609d6b8c90ffaa96b84f133582", "a4f21330282242c9e20b6acf"),
("4296abb9a44432c8656d5605feffc25d71941fd0abf0ff0d61a01a19315a264c", "1bb4c3afd14b9023b33a2f15"),
("206e4f83f8173635d7d554d96b84586fbc3a4280b4403cba5834d3dc8e99a682", "1b7edac989c569cb08f9efd9"),
("57e8dc1b37c6b53a428fc6d7242114eaf3d80b0447bb642703120a257cf7ec52", "5ee82f785f3d5e19df92635b"),
("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "13a36292597404257375e0aa"),
("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0", "f66cb1ba3ee5d164a19668a0"),
("abad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1dea", "1171924a9b34c16878e182a5"),
("abad1deadeadbeefabadbabecafebabe11223344556677889900aabbccddeeff", "7601266085196663727c6522"),
("0000000000000000000000000000000000000000000000000000000000000000", "000000000000000000000000"),
("1000000000000000000000000000000000000000000000000000000000000000", "b6f06eae2266cc0bfca685ca"),
("0001000100010001000a000b000c000d000e000f000100010001000100010001", "6dc2afb4820bb002d9263544"),
("0000000000000000000000000000000000000000000000000000000000000001", "44774376dc1f07545c7fd561"),
] # Pregenerated pairs consisting of 32 bytes of data + 12 bytes of RS ECC (FPGA verified)
# fmt: on
rs = reedsolo.RSCodec(12) # 12 ECC symbols
for pair in pairs:
bin_base = bytearray.fromhex(pair[0])
# Encode the original 32 bytes of data
encoded_data = rs.encode([x for x in bin_base])
assert encoded_data == bytearray.fromhex(pair[0] + pair[1])
| 2,718 | Python | .py | 34 | 69.970588 | 110 | 0.775952 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,575 | test_espsecure.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_espsecure.py | # Tests for espsecure.py using the pytest framework
#
# Assumes openssl binary is in the PATH
import binascii
import io
import os
import os.path
import subprocess
import sys
import tempfile
from collections import namedtuple
from conftest import need_to_install_package_err
import pytest
try:
import esptool
import espsecure
except ImportError:
need_to_install_package_err()
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
@pytest.mark.host_test
class EspSecureTestCase:
def run_espsecure(self, args):
"""
Run espsecure.py with the specified arguments
Returns output as a string if there is any,
raises an exception if espsecure.py fails
"""
cmd = [sys.executable, "-m", "espsecure"] + args.split(" ")
print("\nExecuting {}...".format(" ".join(cmd)))
try:
output = subprocess.check_output(
[str(s) for s in cmd], cwd=TEST_DIR, stderr=subprocess.STDOUT
)
output = output.decode("utf-8")
print(output)
return output
except subprocess.CalledProcessError as e:
print(e.output.decode("utf-8"))
raise e
@classmethod
def setup_class(self):
self.cleanup_files = [] # keep a list of files _open()ed by each test case
@classmethod
def teardown_class(self):
for f in self.cleanup_files:
f.close()
def _open(self, image_file):
f = open(os.path.join(TEST_DIR, "secure_images", image_file), "rb")
self.cleanup_files.append(f)
return f
class TestESP32SecureBootloader(EspSecureTestCase):
def test_digest_bootloader(self):
DBArgs = namedtuple(
"digest_bootloader_args", ["keyfile", "output", "iv", "image"]
)
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
output_file.close()
args = DBArgs(
self._open("256bit_key.bin"),
output_file.name,
self._open("256bit_iv.bin"),
self._open("bootloader.bin"),
)
espsecure.digest_secure_bootloader(args)
with open(output_file.name, "rb") as of:
with self._open("bootloader_digested.bin") as ef:
assert ef.read() == of.read()
finally:
os.unlink(output_file.name)
def test_digest_rsa_public_key(self):
DigestRSAArgs = namedtuple("digest_rsa_public_key_args", ["keyfile", "output"])
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
output_file.close()
args = DigestRSAArgs(
self._open("rsa_secure_boot_signing_key.pem"), output_file.name
)
espsecure.digest_rsa_public_key(args)
with open(output_file.name, "rb") as of:
with self._open("rsa_public_key_digest.bin") as ef:
assert ef.read() == of.read()
finally:
os.unlink(output_file.name)
class TestSigning(EspSecureTestCase):
VerifyArgs = namedtuple(
"verify_signature_args", ["version", "hsm", "hsm_config", "keyfile", "datafile"]
)
SignArgs = namedtuple(
"sign_data_args",
[
"version",
"keyfile",
"output",
"append_signatures",
"hsm",
"hsm_config",
"pub_key",
"signature",
"datafile",
],
)
ExtractKeyArgs = namedtuple(
"extract_public_key_args", ["version", "keyfile", "public_keyfile"]
)
GenerateKeyArgs = namedtuple("generate_key_args", ["version", "scheme", "keyfile"])
def test_key_generation_v1(self):
with tempfile.TemporaryDirectory() as keydir:
# keyfile cannot exist before generation -> tempfile.NamedTemporaryFile()
# cannot be used for keyfile
keyfile_name = os.path.join(keydir, "key.pem")
self.run_espsecure(f"generate_signing_key --version 1 {keyfile_name}")
def test_key_generation_v2(self):
with tempfile.TemporaryDirectory() as keydir:
# keyfile cannot exist before generation -> tempfile.NamedTemporaryFile()
# cannot be used for keyfile
keyfile_name = os.path.join(keydir, "key.pem")
self.run_espsecure(f"generate_signing_key --version 2 {keyfile_name}")
def _test_sign_v1_data(self, key_name):
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
output_file.close()
# Note: signing bootloader is not actually needed
# for ESP32, it's just a handy file to sign
args = self.SignArgs(
"1",
[self._open(key_name)],
output_file.name,
False,
False,
None,
None,
None,
self._open("bootloader.bin"),
)
espsecure.sign_data(args)
with open(output_file.name, "rb") as of:
with self._open("bootloader_signed.bin") as ef:
assert ef.read() == of.read()
finally:
os.unlink(output_file.name)
def test_sign_v1_data(self):
self._test_sign_v1_data("ecdsa_secure_boot_signing_key.pem")
def test_sign_v1_data_pkcs8(self):
self._test_sign_v1_data("ecdsa_secure_boot_signing_key_pkcs8.pem")
def test_sign_v1_with_pre_calculated_signature(self):
# Sign using pre-calculated signature + Verify
signing_pubkey = "ecdsa_secure_boot_signing_pubkey.pem"
pre_calculated_signature = "pre_calculated_bootloader_signature.bin"
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"1",
None,
output_file.name,
False,
False,
None,
[self._open(signing_pubkey)],
[self._open(pre_calculated_signature)],
self._open("bootloader.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"1", False, None, self._open(signing_pubkey), output_file
)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_sign_v2_data(self):
signing_keys = [
"rsa_secure_boot_signing_key.pem",
"ecdsa192_secure_boot_signing_key.pem",
"ecdsa_secure_boot_signing_key.pem",
]
for key in signing_keys:
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
[self._open(key)],
output_file.name,
False,
False,
None,
None,
None,
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs("2", False, None, self._open(key), output_file)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_sign_v2_multiple_keys(self):
# 3 keys + Verify with 3rd key
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
[
self._open("rsa_secure_boot_signing_key.pem"),
self._open("rsa_secure_boot_signing_key2.pem"),
self._open("rsa_secure_boot_signing_key3.pem"),
],
output_file.name,
False,
False,
None,
None,
None,
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key3.pem"),
output_file,
)
espsecure.verify_signature(args)
output_file.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key2.pem"),
output_file,
)
espsecure.verify_signature(args)
output_file.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key.pem"),
output_file,
)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_sign_v2_append_signatures(self):
# Append signatures + Verify with an appended key
# (bootloader_signed_v2.bin already signed with rsa_secure_boot_signing_key.pem)
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
[
self._open("rsa_secure_boot_signing_key2.pem"),
self._open("rsa_secure_boot_signing_key3.pem"),
],
output_file.name,
True,
False,
None,
None,
None,
self._open("bootloader_signed_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key.pem"),
output_file,
)
espsecure.verify_signature(args)
output_file.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key2.pem"),
output_file,
)
espsecure.verify_signature(args)
output_file.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key3.pem"),
output_file,
)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_sign_v2_append_signatures_multiple_steps(self):
# similar to previous test, but sign in two invocations
try:
output_file1 = tempfile.NamedTemporaryFile(delete=False)
output_file2 = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
[self._open("rsa_secure_boot_signing_key2.pem")],
output_file1.name,
True,
False,
None,
None,
None,
self._open("bootloader_signed_v2.bin"),
)
espsecure.sign_data(args)
args = self.SignArgs(
"2",
[self._open("rsa_secure_boot_signing_key3.pem")],
output_file2.name,
True,
False,
None,
None,
None,
output_file1,
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key.pem"),
output_file2,
)
espsecure.verify_signature(args)
output_file2.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key2.pem"),
output_file2,
)
espsecure.verify_signature(args)
output_file2.seek(0)
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key3.pem"),
output_file2,
)
espsecure.verify_signature(args)
finally:
output_file1.close()
os.unlink(output_file1.name)
output_file2.close()
os.unlink(output_file2.name)
def test_sign_v2_with_pre_calculated_signature(self):
# Sign using pre-calculated signature + Verify
signing_keys = [
"rsa_secure_boot_signing_pubkey.pem",
"ecdsa192_secure_boot_signing_pubkey.pem",
"ecdsa_secure_boot_signing_pubkey.pem",
]
pre_calculated_signatures = [
"pre_calculated_bootloader_signature_rsa.bin",
"pre_calculated_bootloader_signature_ecdsa192.bin",
"pre_calculated_bootloader_signature_ecdsa256.bin",
]
for pub_key, signature in zip(signing_keys, pre_calculated_signatures):
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
None,
output_file.name,
False,
False,
None,
[self._open(pub_key)],
[self._open(signature)],
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2", False, None, self._open(pub_key), output_file
)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_sign_v2_with_multiple_pre_calculated_signatures(self):
# Sign using multiple pre-calculated signatures + Verify
signing_pubkeys = [
"rsa_secure_boot_signing_pubkey.pem",
"rsa_secure_boot_signing_pubkey.pem",
"rsa_secure_boot_signing_pubkey.pem",
]
pre_calculated_signatures = [
"pre_calculated_bootloader_signature_rsa.bin",
"pre_calculated_bootloader_signature_rsa.bin",
"pre_calculated_bootloader_signature_rsa.bin",
]
try:
output_file = tempfile.NamedTemporaryFile(delete=False)
args = self.SignArgs(
"2",
None,
output_file.name,
False,
False,
None,
[self._open(pub_key) for pub_key in signing_pubkeys],
[self._open(signature) for signature in pre_calculated_signatures],
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2", False, None, self._open(signing_pubkeys[0]), output_file
)
espsecure.verify_signature(args)
finally:
output_file.close()
os.unlink(output_file.name)
def test_verify_signature_signing_key(self):
# correct key v1
args = self.VerifyArgs(
"1",
False,
None,
self._open("ecdsa_secure_boot_signing_key.pem"),
self._open("bootloader_signed.bin"),
)
espsecure.verify_signature(args)
# correct key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key.pem"),
self._open("bootloader_signed_v2.bin"),
)
espsecure.verify_signature(args)
# correct key v2 (ecdsa256)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa_secure_boot_signing_key.pem"),
self._open("bootloader_signed_v2_ecdsa256.bin"),
)
espsecure.verify_signature(args)
# correct key v2 (ecdsa192)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa192_secure_boot_signing_key.pem"),
self._open("bootloader_signed_v2_ecdsa192.bin"),
)
espsecure.verify_signature(args)
# wrong key v1
args = self.VerifyArgs(
"1",
False,
None,
self._open("ecdsa_secure_boot_signing_key2.pem"),
self._open("bootloader_signed.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature is not valid" in str(cm.value)
# wrong key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key2.pem"),
self._open("bootloader_signed_v2.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# right key, wrong scheme (ecdsa256, v2)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa_secure_boot_signing_key.pem"),
self._open("bootloader_signed.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Invalid datafile" in str(cm.value)
# wrong key v2 (ecdsa256)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa_secure_boot_signing_key2.pem"),
self._open("bootloader_signed_v2_ecdsa256.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# wrong key v2 (ecdsa192)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa192_secure_boot_signing_key2.pem"),
self._open("bootloader_signed_v2_ecdsa192.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# multi-signed wrong key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_key4.pem"),
self._open("bootloader_multi_signed_v2.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
def test_verify_signature_public_key(self):
# correct key v1
args = self.VerifyArgs(
"1",
False,
None,
self._open("ecdsa_secure_boot_signing_pubkey.pem"),
self._open("bootloader_signed.bin"),
)
espsecure.verify_signature(args)
# correct key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_pubkey.pem"),
self._open("bootloader_signed_v2.bin"),
)
espsecure.verify_signature(args)
# correct key v2 (ecdsa256)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa_secure_boot_signing_pubkey.pem"),
self._open("bootloader_signed_v2_ecdsa256.bin"),
)
espsecure.verify_signature(args)
# correct key v2 (ecdsa192)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa192_secure_boot_signing_pubkey.pem"),
self._open("bootloader_signed_v2_ecdsa192.bin"),
)
espsecure.verify_signature(args)
# wrong key v1
args = self.VerifyArgs(
"1",
False,
None,
self._open("ecdsa_secure_boot_signing_pubkey2.pem"),
self._open("bootloader_signed.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature is not valid" in str(cm.value)
# wrong key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_pubkey2.pem"),
self._open("bootloader_signed_v2.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# wrong key v2 (ecdsa256)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa_secure_boot_signing_pubkey2.pem"),
self._open("bootloader_signed_v2_ecdsa256.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# wrong key v2 (ecdsa192)
args = self.VerifyArgs(
"2",
False,
None,
self._open("ecdsa192_secure_boot_signing_pubkey2.pem"),
self._open("bootloader_signed_v2_ecdsa192.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
# multi-signed wrong key v2
args = self.VerifyArgs(
"2",
False,
None,
self._open("rsa_secure_boot_signing_pubkey4.pem"),
self._open("bootloader_multi_signed_v2.bin"),
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature could not be verified with the provided key." in str(cm.value)
def test_extract_binary_public_key(self):
with tempfile.NamedTemporaryFile() as pub_keyfile, tempfile.NamedTemporaryFile() as pub_keyfile2: # noqa E501
args = self.ExtractKeyArgs(
"1", self._open("ecdsa_secure_boot_signing_key.pem"), pub_keyfile
)
espsecure.extract_public_key(args)
args = self.ExtractKeyArgs(
"1", self._open("ecdsa_secure_boot_signing_key2.pem"), pub_keyfile2
)
espsecure.extract_public_key(args)
pub_keyfile.seek(0)
pub_keyfile2.seek(0)
# use correct extracted public key to verify
args = self.VerifyArgs(
"1", False, None, pub_keyfile, self._open("bootloader_signed.bin")
)
espsecure.verify_signature(args)
# use wrong extracted public key to try and verify
args = self.VerifyArgs(
"1", False, None, pub_keyfile2, self._open("bootloader_signed.bin")
)
with pytest.raises(esptool.FatalError) as cm:
espsecure.verify_signature(args)
assert "Signature is not valid" in str(cm.value)
def test_generate_and_extract_key_v2(self):
with tempfile.TemporaryDirectory() as keydir:
# keyfile cannot exist before generation -> tempfile.NamedTemporaryFile()
# cannot be used for keyfile
keyfile_name = os.path.join(keydir, "key.pem")
# We need to manually delete the keyfile as we are iterating over
# different schemes with the same keyfile so instead of using addCleanup,
# we remove it using os.remove at the end of each pass
for scheme in ["rsa3072", "ecdsa192", "ecdsa256"]:
args = self.GenerateKeyArgs("2", scheme, keyfile_name)
espsecure.generate_signing_key(args)
with tempfile.NamedTemporaryFile() as pub_keyfile, open(
keyfile_name, "rb"
) as keyfile:
args = self.ExtractKeyArgs("2", keyfile, pub_keyfile)
espsecure.extract_public_key(args)
os.remove(keyfile_name)
class TestFlashEncryption(EspSecureTestCase):
EncryptArgs = namedtuple(
"encrypt_flash_data_args",
[
"keyfile",
"output",
"address",
"flash_crypt_conf",
"aes_xts",
"plaintext_file",
],
)
DecryptArgs = namedtuple(
"decrypt_flash_data_args",
[
"keyfile",
"output",
"address",
"flash_crypt_conf",
"aes_xts",
"encrypted_file",
],
)
def _test_encrypt_decrypt(
self,
input_plaintext,
expected_ciphertext,
key_path,
offset,
flash_crypt_conf=0xF,
aes_xts=None,
):
original_plaintext = self._open(input_plaintext)
keyfile = self._open(key_path)
ciphertext = io.BytesIO()
args = self.EncryptArgs(
keyfile, ciphertext, offset, flash_crypt_conf, aes_xts, original_plaintext
)
espsecure.encrypt_flash_data(args)
original_plaintext.seek(0)
assert original_plaintext.read() != ciphertext.getvalue()
with self._open(expected_ciphertext) as f:
assert f.read() == ciphertext.getvalue()
ciphertext.seek(0)
keyfile.seek(0)
plaintext = io.BytesIO()
args = self.DecryptArgs(
keyfile, plaintext, offset, flash_crypt_conf, aes_xts, ciphertext
)
espsecure.decrypt_flash_data(args)
original_plaintext.seek(0)
assert original_plaintext.read() == plaintext.getvalue()
class TestESP32FlashEncryption(TestFlashEncryption):
def test_encrypt_decrypt_bootloader(self):
self._test_encrypt_decrypt(
"bootloader.bin", "bootloader-encrypted.bin", "256bit_key.bin", 0x1000, 0xF
)
def test_encrypt_decrypt_app(self):
self._test_encrypt_decrypt(
"hello-world-signed.bin",
"hello-world-signed-encrypted.bin",
"ef-flashencryption-key.bin",
0x20000,
0xF,
)
def test_encrypt_decrypt_non_default_conf(self):
"""Try some non-default (non-recommended) flash_crypt_conf settings"""
for conf in [0x0, 0x3, 0x9, 0xC]:
self._test_encrypt_decrypt(
"bootloader.bin",
f"bootloader-encrypted-conf{conf:x}.bin",
"256bit_key.bin",
0x1000,
conf,
)
class TestAesXtsFlashEncryption(TestFlashEncryption):
def test_encrypt_decrypt_bootloader(self):
self._test_encrypt_decrypt(
"bootloader.bin",
"bootloader-encrypted-aes-xts.bin",
"256bit_key.bin",
0x1000,
aes_xts=True,
)
def test_encrypt_decrypt_app(self):
self._test_encrypt_decrypt(
"hello-world-signed.bin",
"hello-world-signed-encrypted-aes-xts.bin",
"ef-flashencryption-key.bin",
0x20000,
aes_xts=True,
)
def test_encrypt_decrypt_app_512_bit_key(self):
self._test_encrypt_decrypt(
"hello-world-signed.bin",
"hello-world-signed-encrypted-aes-xts-256.bin",
"512bit_key.bin",
0x10000,
aes_xts=True,
)
def test_padding(self):
# Random 2048 bits hex string
plaintext = binascii.unhexlify(
"c33b7c49f12a969a9bb45af5f660b73f"
"3b372685012da570df1cf99d1a82eabb"
"fdf6aa16b9675bd8a2f95e871513e175"
"3bc89f57986ecfb2707a3d3b59a46968"
"5e6609d2e9c21d4b2310571175e6e3de"
"2656ee22243f557b925ef39ff782ab56"
"f821e6859ee852000daae7c03a7c77ce"
"58744f15fbdf0ad4ae6e964aedd6316a"
"cf0e36935eef895cd14a60fe682fb971"
"eb239eae38b770bdf969017c9decfd91"
"b7c60329fb0c896684f0e7415f99dec1"
"da0572fac360a3e6d7219973a7de07e5"
"33b5abfdf5917ed5bfe54d660a6f5047"
"32fdb8d07259bfcdc67da87293857c11"
"427b2bae5f00da4a4b2b00b588ff5109"
"4c41f07f02f680f8826841b43da3f25b"
)
plaintext_file = io.BytesIO(plaintext)
ciphertext_full_block = io.BytesIO()
keyfile = self._open("256bit_key.bin")
address = 0x1000
encrypt_args_padded = self.EncryptArgs(
keyfile, ciphertext_full_block, address, None, "aes_xts", plaintext_file
)
espsecure.encrypt_flash_data(encrypt_args_padded)
# Test with different number of bytes per encryption call
# Final ciphertext should still be the same if padding is done correctly
bytes_per_encrypt = [16, 32, 64, 128]
for b in bytes_per_encrypt:
ciphertext = io.BytesIO()
num_enc_calls = len(plaintext) // b
for i in range(0, num_enc_calls):
keyfile.seek(0)
offset = b * i
# encrypt the whole plaintext a substring of b bytes at a time
plaintext_sub = io.BytesIO(plaintext[offset : offset + b])
encrypt_args = self.EncryptArgs(
keyfile,
ciphertext,
address + offset,
None,
"aes_xts",
plaintext_sub,
)
espsecure.encrypt_flash_data(encrypt_args)
assert ciphertext_full_block.getvalue() == ciphertext.getvalue()
class TestDigest(EspSecureTestCase):
def test_digest_private_key(self):
with tempfile.NamedTemporaryFile() as f:
outfile_name = f.name
self.run_espsecure(
"digest_private_key "
"--keyfile secure_images/ecdsa_secure_boot_signing_key.pem "
f"{outfile_name}"
)
with open(outfile_name, "rb") as f:
assert f.read() == binascii.unhexlify(
"7b7b53708fc89d5e0b2df2571fb8f9d778f61a422ff1101a22159c4b34aad0aa"
)
def test_digest_private_key_with_invalid_output(self, capsys):
fname = "secure_images/ecdsa_secure_boot_signing_key.pem"
with pytest.raises(subprocess.CalledProcessError):
self.run_espsecure(f"digest_private_key --keyfile {fname} {fname}")
output = capsys.readouterr().out
assert "should not be the same!" in output
| 31,254 | Python | .py | 825 | 25.483636 | 118 | 0.544405 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,576 | test_image_info.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_image_info.py | import os
import os.path
import subprocess
import sys
from conftest import need_to_install_package_err
import pytest
try:
import esptool # noqa: F401
except ImportError:
need_to_install_package_err()
IMAGES_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "images")
ESP8266_BIN = "not_4_byte_aligned.bin"
def read_image(filename):
with open(os.path.join(IMAGES_DIR, filename), "rb") as f:
return f.read()
@pytest.mark.host_test
class TestImageInfo:
def run_image_info(self, chip, file, version=None):
"""Runs image_info on a binary file.
Returns the command output.
Filenames are relative to the 'test/images' directory.
"""
cmd = [
sys.executable,
"-m",
"esptool",
"--chip",
chip,
"image_info",
]
if version is not None:
cmd += ["--version", str(version)]
cmd += ["".join([IMAGES_DIR, os.sep, file])]
print("\nExecuting {}".format(" ".join(cmd)))
try:
output = subprocess.check_output(cmd)
output = output.decode("utf-8")
print(output) # for more complete stdout logs on failure
assert (
"warning" not in output.lower()
), "image_info should not output warnings"
return output
except subprocess.CalledProcessError as e:
print(e.output)
raise
def test_v1_esp32(self):
out = self.run_image_info("esp32", "bootloader_esp32.bin")
assert "Entry point: 4009816c" in out, "Wrong entry point"
assert "Checksum: 83 (valid)" in out, "Invalid checksum"
assert "4 segments" in out, "Wrong number of segments"
assert (
"Segment 3: len 0x01068 load 0x40078000 file_offs 0x00000b64 [CACHE_APP]"
in out
), "Wrong segment info"
def test_v1_esp8266(self):
out = self.run_image_info("esp8266", ESP8266_BIN)
assert "Image version: 1" in out, "Wrong image version"
assert "Entry point: 40101844" in out, "Wrong entry point"
assert "Checksum: 6b (valid)" in out, "Invalid checksum"
assert "1 segments" in out, "Wrong number of segments"
assert (
"Segment 1: len 0x00014 load 0x40100000 file_offs 0x00000008 [IRAM]" in out
), "Wrong segment info"
def test_v2_esp32c3(self):
out = self.run_image_info("esp32c3", "bootloader_esp32c3.bin", "2")
# Header
assert "Entry point: 0x403c0000" in out, "Wrong entry point"
assert "Segments: 4" in out, "Wrong num of segments"
assert "Flash size: 2MB" in out, "Wrong flash size"
assert "Flash freq: 40m" in out, "Wrong flash frequency"
assert "Flash mode: DIO" in out, "Wrong flash mode"
# Extended header
assert "WP pin: 0xee (disabled)" in out, "Wrong WP pin"
assert "Chip ID: 5 (ESP32-C3)" in out, "Wrong chip ID"
assert (
"clk_drv: 0x0, q_drv: 0x0, d_drv: 0x0, "
"cs0_drv: 0x0, hd_drv: 0x0, wp_drv: 0x0" in out
), "Wrong flash pins drive settings"
assert "Minimal chip revision: v0.0" in out, "Wrong min revision"
assert "Maximal chip revision: v0.0" in out, "Wrong min revision"
# Segments
assert (
"2 0x01864 0x3fcd6114 0x00000034 DRAM, BYTE_ACCESSIBLE" in out
), "Wrong segment info"
# Footer
assert "Checksum: 0x77 (valid)" in out, "Invalid checksum"
assert "c0a9d6d882b65580da2e5e6347 (valid)" in out, "Invalid hash"
# Check output against individual bytes in the headers
hdr = read_image("bootloader_esp32c3.bin")[:8]
ex_hdr = read_image("bootloader_esp32c3.bin")[8:24]
assert f"Segments: {hdr[1]}" in out, "Wrong num of segments"
assert f"WP pin: {ex_hdr[0]:#02x}" in out, "Wrong WP pin"
assert f"Chip ID: {ex_hdr[4]}" in out, "Wrong chip ID"
if ex_hdr[15] == 1: # Hash appended
assert "Validation hash: 4faeab1bd3fd" in out, "Invalid hash"
def test_v2_esp8266(self):
out = self.run_image_info("esp8266", ESP8266_BIN, "2")
assert "Image version: 1" in out, "Wrong image version"
assert "Entry point: 0x40101844" in out, "Wrong entry point"
assert "Flash size: 512KB" in out, "Wrong flash size"
assert "Flash freq: 40m" in out, "Wrong flash frequency"
assert "Flash mode: QIO" in out, "Wrong flash mode"
assert "Checksum: 0x6b (valid)" in out, "Invalid checksum"
assert "Segments: 1" in out, "Wrong number of segments"
assert "1 0x00014 0x40100000 0x00000008 IRAM" in out, "Wrong segment info"
def test_image_type_detection(self):
# ESP8266, version 1 and 2
out = self.run_image_info("auto", ESP8266_BIN, "1")
assert "Detected image type: ESP8266" in out
assert "Segment 1: len 0x00014" in out
out = self.run_image_info("auto", ESP8266_BIN, "2")
assert "Detected image type: ESP8266" in out
assert "Flash freq: 40m" in out
out = self.run_image_info("auto", "esp8266_deepsleep.bin", "2")
assert "Detected image type: ESP8266" in out
# ESP32, with and without detection
out = self.run_image_info("auto", "bootloader_esp32.bin", "2")
assert "Detected image type: ESP32" in out
out = self.run_image_info(
"auto", "ram_helloworld/helloworld-esp32_edit.bin", "2"
)
assert "Detected image type: ESP32" in out
out = self.run_image_info("esp32", "bootloader_esp32.bin", "2")
assert "Detected image type: ESP32" not in out
# ESP32-C3
out = self.run_image_info("auto", "bootloader_esp32c3.bin", "2")
assert "Detected image type: ESP32-C3" in out
# ESP32-S3
out = self.run_image_info("auto", "esp32s3_header.bin", "2")
assert "Detected image type: ESP32-S3" in out
def test_invalid_image_type_detection(self, capsys):
with pytest.raises(subprocess.CalledProcessError):
# Invalid image
self.run_image_info("auto", "one_kb.bin", "2")
assert (
"This is not a valid image (invalid magic number: 0xed)"
in capsys.readouterr().out
)
def test_application_info(self):
out = self.run_image_info("auto", "esp_idf_blink_esp32s2.bin", "2")
assert "Application information" in out
assert "Project name: blink" in out
assert "App version: qa-test-v5.0-20220830-4-g4532e6" in out
assert "Secure version: 0" in out
assert "Compile time: Sep 13 2022" in out
assert "19:46:07" in out
assert "3059e6b55a965865febd28fa9f6028ad5" in out
assert "cd0dab311febb0a3ea79eaa223ac2b0" in out
assert "ESP-IDF: v5.0-beta1-427-g4532e6e0b2-dirt" in out
# No application info in image
out = self.run_image_info("auto", "bootloader_esp32.bin", "2")
assert "Application information" not in out
out = self.run_image_info("auto", ESP8266_BIN, "2")
assert "Application information" not in out
def test_bootloader_info(self):
# This bootloader binary is built from "hello_world" project
# with default settings, IDF version is v5.2.
out = self.run_image_info("esp32", "bootloader_esp32_v5_2.bin", "2")
assert "File size: 26768 (bytes)" in out
assert "Bootloader information" in out
assert "Bootloader version: 1" in out
assert "ESP-IDF: v5.2-dev-254-g1950b15" in out
assert "Compile time: Apr 25 2023 00:13:32" in out
| 7,714 | Python | .py | 163 | 38.374233 | 87 | 0.620364 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,577 | test_espefuse.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_espefuse.py | # HOST_TEST for espefuse.py using the pytest framework
#
# Supports esp32, esp32s2, esp32s3beta2, esp32s3,
# esp32c3, esp32h2beta1, esp32c2, esp32c6
#
# How to use:
#
# Run as HOST_TEST (without a physical connection to a chip):
# - `pytest test_espefuse.py --chip esp32`
# - `pytest test_espefuse.py --chip esp32s2`
#
# OR
#
# Run as TEST on FPGA (connection to FPGA with a flashed image):
# required two COM ports
# - `pytest test_espefuse.py \
# --chip esp32 --port /dev/ttyUSB0 --reset-port /dev/ttyUSB1`
#
# where - --port - a port for espefuse.py operation
# - --reset-port - a port to clear efuses (connect RTS or DTR ->- J14 pin 39)
#
# Note: For FPGA with ESP32 image, you need to set an env variable ESPTOOL_ENV_FPGA to 1
# to slow down the connection sequence
# because of a long delay (~6 seconds) after resetting the FPGA.
# This is not necessary when using other images than ESP32
import os
import subprocess
import sys
import tempfile
import time
from bitstring import BitStream
# Make command line options --port, --reset-port and --chip available
from conftest import arg_chip, arg_port, arg_reset_port, need_to_install_package_err
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
IMAGES_DIR = os.path.join(TEST_DIR, "images", "efuse")
S_IMAGES_DIR = os.path.join(TEST_DIR, "secure_images")
EFUSE_S_DIR = os.path.join(TEST_DIR, "efuse_scripts")
import pytest
try:
from espefuse import SUPPORTED_CHIPS
except ImportError:
need_to_install_package_err()
SUPPORTED_CHIPS = list(SUPPORTED_CHIPS.keys())
import serial
# Set reset_port if --reset-port cmdline option is specified
# This activates testing with real hardware (FPGA)
reset_port = (
serial.Serial(arg_reset_port, 115200) if arg_reset_port is not None else None
)
if arg_chip not in SUPPORTED_CHIPS:
pytest.exit(f"{arg_chip} is not a supported target, choose from {SUPPORTED_CHIPS}")
print(f"\nHost tests of espefuse.py for {arg_chip}:")
print("Running espefuse.py tests...")
@pytest.mark.host_test
class EfuseTestCase:
def setup_method(self):
if reset_port is None:
self.efuse_file = tempfile.NamedTemporaryFile(delete=False)
self.base_cmd = (
f"{sys.executable} -m espefuse --chip {arg_chip} "
f"--virt --path-efuse-file {self.efuse_file.name} -d"
)
else:
self.base_cmd = (
f"{sys.executable} -m espefuse --chip {arg_chip} "
f"--port {arg_port} -d"
)
self.reset_efuses()
def teardown_method(self):
if reset_port is None:
self.efuse_file.close()
os.unlink(self.efuse_file.name)
def reset_efuses(self):
# reset and zero efuses
reset_port.dtr = False
reset_port.rts = False
time.sleep(0.05)
reset_port.dtr = True
reset_port.rts = True
time.sleep(0.05)
reset_port.dtr = False
reset_port.rts = False
def get_esptool(self):
if reset_port is not None:
import esptool
esp = esptool.cmds.detect_chip(port=arg_port)
del esptool
else:
import espefuse
efuse = espefuse.SUPPORTED_CHIPS[arg_chip].efuse_lib
esp = efuse.EmulateEfuseController(self.efuse_file.name)
del espefuse
del efuse
return esp
def _set_34_coding_scheme(self):
self.espefuse_py("burn_efuse CODING_SCHEME 1")
def check_data_block_in_log(
self, log, file_path, repeat=1, reverse_order=False, offset=0
):
with open(file_path, "rb") as f:
data = BitStream("0x00") * offset + BitStream(f)
blk = data.readlist(f"{data.len // 8}*uint:8")
blk = blk[::-1] if reverse_order else blk
hex_blk = " ".join(f"{num:02x}" for num in blk)
assert repeat == log.count(hex_blk)
def espefuse_not_virt_py(self, cmd, check_msg=None, ret_code=0):
full_cmd = " ".join((f"{sys.executable} -m espefuse", cmd))
return self._run_command(full_cmd, check_msg, ret_code)
def espefuse_py(self, cmd, do_not_confirm=True, check_msg=None, ret_code=0):
full_cmd = " ".join(
[self.base_cmd, "--do-not-confirm" if do_not_confirm else "", cmd]
)
output = self._run_command(full_cmd, check_msg, ret_code)
self._run_command(
" ".join([self.base_cmd, "check_error"]), "No errors detected", 0
)
print(output)
return output
def _run_command(self, cmd, check_msg, ret_code):
try:
p = subprocess.Popen(
cmd.split(),
shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
universal_newlines=True,
)
output, _ = p.communicate()
returncode = p.returncode
if check_msg:
assert check_msg in output
if returncode:
print(output)
print(cmd)
assert ret_code == returncode
return output
except subprocess.CalledProcessError as error:
print(error)
raise
class TestReadCommands(EfuseTestCase):
def test_help(self):
self.espefuse_not_virt_py("--help", check_msg="usage: __main__.py [-h]")
self.espefuse_not_virt_py(f"--chip {arg_chip} --help")
def test_help2(self):
self.espefuse_not_virt_py("", check_msg="usage: __main__.py [-h]", ret_code=1)
def test_dump(self):
self.espefuse_py("dump -h")
self.espefuse_py("dump")
def test_summary(self):
self.espefuse_py("summary -h")
self.espefuse_py("summary")
def test_summary_json(self):
self.espefuse_py("summary --format json")
def test_get_custom_mac(self):
self.espefuse_py("get_custom_mac -h")
if arg_chip == "esp32":
right_msg = "Custom MAC Address is not set in the device."
else:
right_msg = "Custom MAC Address: 00:00:00:00:00:00 (OK)"
self.espefuse_py("get_custom_mac", check_msg=right_msg)
def test_adc_info(self):
self.espefuse_py("adc_info -h")
self.espefuse_py("adc_info")
def test_check_error(self):
self.espefuse_py("check_error -h")
self.espefuse_py("check_error")
self.espefuse_py("check_error --recovery")
class TestReadProtectionCommands(EfuseTestCase):
def test_read_protect_efuse(self):
self.espefuse_py("read_protect_efuse -h")
if arg_chip == "esp32":
cmd = "read_protect_efuse \
CODING_SCHEME \
MAC_VERSION \
BLOCK1 \
BLOCK2 \
BLOCK3"
count_protects = 5
elif arg_chip == "esp32c2":
cmd = "read_protect_efuse \
BLOCK_KEY0_LOW_128"
count_protects = 1
else:
self.espefuse_py(
"burn_efuse \
KEY_PURPOSE_0 HMAC_UP \
KEY_PURPOSE_1 XTS_AES_128_KEY \
KEY_PURPOSE_2 XTS_AES_128_KEY \
KEY_PURPOSE_3 HMAC_DOWN_ALL \
KEY_PURPOSE_4 HMAC_DOWN_JTAG \
KEY_PURPOSE_5 HMAC_DOWN_DIGITAL_SIGNATURE"
)
cmd = "read_protect_efuse \
BLOCK_KEY0 \
BLOCK_KEY1 \
BLOCK_KEY2 \
BLOCK_KEY3 \
BLOCK_KEY4 \
BLOCK_KEY5"
count_protects = 6
self.espefuse_py(cmd)
output = self.espefuse_py(cmd)
assert count_protects == output.count("is already read protected")
def test_read_protect_efuse2(self):
self.espefuse_py("write_protect_efuse RD_DIS")
if arg_chip == "esp32":
efuse_name = "CODING_SCHEME"
elif arg_chip == "esp32c2":
efuse_name = "BLOCK_KEY0_HI_128"
else:
efuse_name = "BLOCK_SYS_DATA2"
self.espefuse_py(
f"read_protect_efuse {efuse_name}",
check_msg="A fatal error occurred: This efuse cannot be read-disabled "
"due the to RD_DIS field is already write-disabled",
ret_code=2,
)
@pytest.mark.skipif(arg_chip != "esp32", reason="when the purpose of BLOCK2 is set")
def test_read_protect_efuse3(self):
self.espefuse_py("burn_efuse ABS_DONE_1 1")
self.espefuse_py(f"burn_key BLOCK2 {IMAGES_DIR}/256bit")
self.espefuse_py(
"read_protect_efuse BLOCK2",
check_msg="Secure Boot V2 is on (ABS_DONE_1 = True), "
"BLOCK2 must be readable, stop this operation!",
ret_code=2,
)
def test_read_protect_efuse4(self):
if arg_chip == "esp32":
self.espefuse_py(f"burn_key BLOCK2 {IMAGES_DIR}/256bit")
msg = "must be readable, please stop this operation!"
self.espefuse_py("read_protect_efuse BLOCK2", check_msg=msg)
elif arg_chip == "esp32c2":
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit_key SECURE_BOOT_DIGEST"
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY0",
check_msg="A fatal error occurred: "
"BLOCK_KEY0 must be readable, stop this operation!",
ret_code=2,
)
else:
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/256bit USER \
BLOCK_KEY1 {IMAGES_DIR}/256bit RESERVED \
BLOCK_KEY2 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST0 \
BLOCK_KEY3 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST1 \
BLOCK_KEY4 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST2 \
BLOCK_KEY5 {IMAGES_DIR}/256bit HMAC_UP"
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY0",
check_msg="A fatal error occurred: "
"BLOCK_KEY0 must be readable, stop this operation!",
ret_code=2,
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY1",
check_msg="A fatal error occurred: "
"BLOCK_KEY1 must be readable, stop this operation!",
ret_code=2,
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY2",
check_msg="A fatal error occurred: "
"BLOCK_KEY2 must be readable, stop this operation!",
ret_code=2,
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY3",
check_msg="A fatal error occurred: "
"BLOCK_KEY3 must be readable, stop this operation!",
ret_code=2,
)
self.espefuse_py(
"read_protect_efuse BLOCK_KEY4",
check_msg="A fatal error occurred: "
"BLOCK_KEY4 must be readable, stop this operation!",
ret_code=2,
)
self.espefuse_py("read_protect_efuse BLOCK_KEY5")
@pytest.mark.skipif(
arg_chip != "esp32",
reason="system parameters efuse read-protection is supported only by esp32, "
"other chips protect whole blocks",
)
def test_burn_and_read_protect_efuse(self):
self.espefuse_py(
"burn_efuse FLASH_CRYPT_CONFIG 15 RD_DIS 8",
check_msg="Efuse FLASH_CRYPT_CONFIG is read-protected. "
"Read back the burn value is not possible.",
)
class TestWriteProtectionCommands(EfuseTestCase):
def test_write_protect_efuse(self):
self.espefuse_py("write_protect_efuse -h")
if arg_chip == "esp32":
efuse_lists = """WR_DIS RD_DIS CODING_SCHEME
XPD_SDIO_FORCE XPD_SDIO_REG XPD_SDIO_TIEH SPI_PAD_CONFIG_CLK
FLASH_CRYPT_CNT UART_DOWNLOAD_DIS FLASH_CRYPT_CONFIG
ADC_VREF BLOCK1 BLOCK2 BLOCK3"""
efuse_lists2 = "WR_DIS RD_DIS"
elif arg_chip == "esp32c2":
efuse_lists = """RD_DIS DIS_DOWNLOAD_ICACHE
XTS_KEY_LENGTH_256 UART_PRINT_CONTROL"""
efuse_lists2 = "RD_DIS DIS_DOWNLOAD_ICACHE"
else:
efuse_lists = """RD_DIS DIS_ICACHE DIS_FORCE_DOWNLOAD
DIS_CAN SOFT_DIS_JTAG DIS_DOWNLOAD_MANUAL_ENCRYPT
USB_EXCHG_PINS WDT_DELAY_SEL SPI_BOOT_CRYPT_CNT
SECURE_BOOT_KEY_REVOKE0 SECURE_BOOT_KEY_REVOKE1
SECURE_BOOT_KEY_REVOKE2 KEY_PURPOSE_0 KEY_PURPOSE_1
KEY_PURPOSE_2 KEY_PURPOSE_3 KEY_PURPOSE_4 KEY_PURPOSE_5
SECURE_BOOT_EN SECURE_BOOT_AGGRESSIVE_REVOKE FLASH_TPUW
DIS_DOWNLOAD_MODE
ENABLE_SECURITY_DOWNLOAD UART_PRINT_CONTROL
MAC OPTIONAL_UNIQUE_ID
BLOCK_USR_DATA BLOCK_KEY0 BLOCK_KEY1
BLOCK_KEY2 BLOCK_KEY3 BLOCK_KEY4 BLOCK_KEY5"""
if arg_chip not in ["esp32h2", "esp32h2beta1"] and arg_chip not in [
"esp32c6"
]:
efuse_lists += """ DIS_DOWNLOAD_ICACHE
SPI_PAD_CONFIG_CLK SPI_PAD_CONFIG_Q
SPI_PAD_CONFIG_D SPI_PAD_CONFIG_CS SPI_PAD_CONFIG_HD
SPI_PAD_CONFIG_WP SPI_PAD_CONFIG_DQS SPI_PAD_CONFIG_D4
SPI_PAD_CONFIG_D5 SPI_PAD_CONFIG_D6 SPI_PAD_CONFIG_D7"""
efuse_lists2 = "RD_DIS DIS_ICACHE"
self.espefuse_py(f"write_protect_efuse {efuse_lists}")
output = self.espefuse_py(f"write_protect_efuse {efuse_lists2}")
assert output.count("is already write protected") == 2
def test_write_protect_efuse2(self):
if arg_chip == "esp32":
self.espefuse_py("write_protect_efuse WR_DIS")
self.espefuse_py(
"write_protect_efuse CODING_SCHEME",
check_msg="A fatal error occurred: This efuse cannot be write-disabled "
"due to the WR_DIS field is already write-disabled",
ret_code=2,
)
class TestBurnCustomMacCommands(EfuseTestCase):
def test_burn_custom_mac(self):
self.espefuse_py("burn_custom_mac -h")
cmd = "burn_custom_mac AA:CD:EF:11:22:33"
mac = "aa:cd:ef:11:22:33"
if arg_chip == "esp32":
self.espefuse_py(
cmd, check_msg=f"Custom MAC Address version 1: {mac} (CRC 0x63 OK)"
)
else:
self.espefuse_py(cmd, check_msg=f"Custom MAC Address: {mac} (OK)")
def test_burn_custom_mac2(self):
self.espefuse_py(
"burn_custom_mac AA:CD:EF:11:22:33:44",
check_msg="A fatal error occurred: MAC Address needs to be a 6-byte "
"hexadecimal format separated by colons (:)!",
ret_code=2,
)
def test_burn_custom_mac3(self):
self.espefuse_py(
"burn_custom_mac AB:CD:EF:11:22:33",
check_msg="A fatal error occurred: Custom MAC must be a unicast MAC!",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_custom_mac_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py("burn_custom_mac -h")
self.espefuse_py(
"burn_custom_mac AA:CD:EF:01:02:03",
check_msg="Custom MAC Address version 1: aa:cd:ef:01:02:03 (CRC 0x56 OK)",
)
self.espefuse_py(
"get_custom_mac",
check_msg="Custom MAC Address version 1: aa:cd:ef:01:02:03 (CRC 0x56 OK)",
)
self.espefuse_py(
"burn_custom_mac FE:22:33:44:55:66",
check_msg="New value contains some bits that cannot be cleared "
"(value will be 0x675745ffeffe)",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip in ["esp32c2", "esp32h2beta1", "esp32c3", "esp32c6", "esp32h2"],
reason=f"TODO: add support set_flash_voltage for {arg_chip}",
)
class TestSetFlashVoltageCommands(EfuseTestCase):
def test_set_flash_voltage_1_8v(self):
self.espefuse_py("set_flash_voltage -h")
vdd = "VDD_SDIO" if arg_chip == "esp32" else "VDD_SPI"
self.espefuse_py(
"set_flash_voltage 1.8V",
check_msg=f"Set internal flash voltage regulator ({vdd}) to 1.8V.",
)
if arg_chip == "esp32":
error_msg = "A fatal error occurred: "
"Can't set flash regulator to OFF as XPD_SDIO_REG efuse is already burned"
else:
error_msg = "A fatal error occurred: "
"Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned"
self.espefuse_py(
"set_flash_voltage 3.3V",
check_msg=f"Enable internal flash voltage regulator ({vdd}) to 3.3V.",
)
self.espefuse_py("set_flash_voltage OFF", check_msg=error_msg, ret_code=2)
def test_set_flash_voltage_3_3v(self):
vdd = "VDD_SDIO" if arg_chip == "esp32" else "VDD_SPI"
self.espefuse_py(
"set_flash_voltage 3.3V",
check_msg=f"Enable internal flash voltage regulator ({vdd}) to 3.3V.",
)
if arg_chip == "esp32":
error_msg = "A fatal error occurred: "
"Can't set regulator to 1.8V is XPD_SDIO_TIEH efuse is already burned"
else:
error_msg = "A fatal error occurred: "
"Can't set regulator to 1.8V is VDD_SPI_TIEH efuse is already burned"
self.espefuse_py("set_flash_voltage 1.8V", check_msg=error_msg, ret_code=2)
if arg_chip == "esp32":
error_msg = "A fatal error occurred: "
"Can't set flash regulator to OFF as XPD_SDIO_REG efuse is already burned"
else:
error_msg = "A fatal error occurred: "
"Can't set flash regulator to OFF as VDD_SPI_XPD efuse is already burned"
self.espefuse_py("set_flash_voltage OFF", check_msg=error_msg, ret_code=2)
def test_set_flash_voltage_off(self):
vdd = "VDD_SDIO" if arg_chip == "esp32" else "VDD_SPI"
self.espefuse_py(
"set_flash_voltage OFF",
check_msg=f"Disable internal flash voltage regulator ({vdd})",
)
self.espefuse_py(
"set_flash_voltage 3.3V",
check_msg=f"Enable internal flash voltage regulator ({vdd}) to 3.3V.",
)
def test_set_flash_voltage_off2(self):
vdd = "VDD_SDIO" if arg_chip == "esp32" else "VDD_SPI"
self.espefuse_py(
"set_flash_voltage OFF",
check_msg=f"Disable internal flash voltage regulator ({vdd})",
)
self.espefuse_py(
"set_flash_voltage 1.8V",
check_msg=f"Set internal flash voltage regulator ({vdd}) to 1.8V.",
)
@pytest.mark.skipif(arg_chip != "esp32c3", reason="Not necessary fo all chips")
class TestValueArgForBurnEfuseCommands(EfuseTestCase):
def test_efuse_is_bool_given_none(self):
self.espefuse_py("burn_efuse SECURE_BOOT_KEY_REVOKE0")
def test_efuse_is_bool_given_0(self):
self.espefuse_py(
"burn_efuse SECURE_BOOT_KEY_REVOKE0 0",
check_msg="A fatal error occurred: "
"New value is not accepted for efuse 'SECURE_BOOT_KEY_REVOKE0' "
"(will always burn 0->1), given value=0",
ret_code=2,
)
def test_efuse_is_bool_given_2(self):
self.espefuse_py(
"burn_efuse SECURE_BOOT_KEY_REVOKE0 2",
check_msg="A fatal error occurred: "
"New value is not accepted for efuse 'SECURE_BOOT_KEY_REVOKE0' "
"(will always burn 0->1), given value=2",
ret_code=2,
)
def test_efuse_is_bytes_ok(self):
self.espefuse_py(
"burn_efuse OPTIONAL_UNIQUE_ID 0x12345678123456781234567812345678"
)
def test_efuse_is_bytes_given_short_val(self):
self.espefuse_py(
"burn_efuse OPTIONAL_UNIQUE_ID 0x1234567812345678",
check_msg="A fatal error occurred: "
"The length of efuse 'OPTIONAL_UNIQUE_ID' (128 bits) "
"(given len of the new value= 64 bits)",
ret_code=2,
)
def test_efuse_is_bytes_given_none(self):
self.espefuse_py(
"burn_efuse OPTIONAL_UNIQUE_ID",
check_msg="A fatal error occurred: "
"New value required for efuse 'OPTIONAL_UNIQUE_ID' (given None)",
ret_code=2,
)
def test_efuse_is_int_ok(self):
self.espefuse_py("burn_efuse SPI_PAD_CONFIG_D 7")
def test_efuse_is_int_given_out_of_range_val(self):
self.espefuse_py(
"burn_efuse SPI_PAD_CONFIG_D 200",
check_msg="A fatal error occurred: "
"200 is too large an unsigned integer for a bitstring "
"of length 6. The allowed range is [0, 63].",
ret_code=2,
)
def test_efuse_is_int_given_none(self):
self.espefuse_py(
"burn_efuse SPI_PAD_CONFIG_D",
check_msg="A fatal error occurred: "
"New value required for efuse 'SPI_PAD_CONFIG_D' (given None)",
ret_code=2,
)
def test_efuse_is_int_given_0(self):
self.espefuse_py(
"burn_efuse SPI_PAD_CONFIG_D 0",
check_msg="A fatal error occurred: "
"New value should not be 0 for 'SPI_PAD_CONFIG_D' "
"(given value= 0)",
ret_code=2,
)
def test_efuse_is_bitcount_given_out_of_range_val(self):
self.espefuse_py(
"burn_efuse SPI_BOOT_CRYPT_CNT 9",
check_msg="A fatal error occurred: "
"9 is too large an unsigned integer for a bitstring "
"of length 3. The allowed range is [0, 7].",
ret_code=2,
)
def test_efuse_is_bitcount_given_increase_over_max(self):
self.espefuse_py("burn_efuse SPI_BOOT_CRYPT_CNT")
self.espefuse_py("burn_efuse SPI_BOOT_CRYPT_CNT")
self.espefuse_py("burn_efuse SPI_BOOT_CRYPT_CNT")
self.espefuse_py(
"burn_efuse SPI_BOOT_CRYPT_CNT",
check_msg="A fatal error occurred: "
"15 is too large an unsigned integer for a bitstring "
"of length 3. The allowed range is [0, 7].",
ret_code=2,
)
class TestBurnEfuseCommands(EfuseTestCase):
@pytest.mark.skipif(
arg_chip != "esp32",
reason="IO pins 30 & 31 cannot be set for SPI flash only on esp32",
)
def test_set_spi_flash_pin_efuses(self):
self.espefuse_py(
"burn_efuse SPI_PAD_CONFIG_HD 30",
check_msg="A fatal error occurred: "
"IO pins 30 & 31 cannot be set for SPI flash. 0-29, 32 & 33 only.",
ret_code=2,
)
self.espefuse_py(
"burn_efuse SPI_PAD_CONFIG_Q 0x23",
check_msg="A fatal error occurred: "
"IO pin 35 cannot be set for SPI flash. 0-29, 32 & 33 only.",
ret_code=2,
)
output = self.espefuse_py("burn_efuse SPI_PAD_CONFIG_CS0 33")
assert "(Override SD_CMD pad (GPIO11/SPICS0)) 0b00000 -> 0b11111" in output
assert "BURN BLOCK0 - OK (all write block bits are set)" in output
def test_burn_mac_custom_efuse(self):
crc_msg = "(OK)"
self.espefuse_py("burn_efuse -h")
if arg_chip == "esp32":
self.espefuse_py(
"burn_efuse MAC AA:CD:EF:01:02:03",
check_msg="Writing Factory MAC address is not supported",
ret_code=2,
)
self.espefuse_py("burn_efuse MAC_VERSION 1")
crc_msg = "(CRC 0x56 OK)"
if arg_chip == "esp32c2":
self.espefuse_py("burn_efuse CUSTOM_MAC_USED 1")
self.espefuse_py("burn_efuse -h")
self.espefuse_py(
"burn_efuse CUSTOM_MAC AB:CD:EF:01:02:03",
check_msg="A fatal error occurred: Custom MAC must be a unicast MAC!",
ret_code=2,
)
self.espefuse_py("burn_efuse CUSTOM_MAC AA:CD:EF:01:02:03")
self.espefuse_py("get_custom_mac", check_msg=f"aa:cd:ef:01:02:03 {crc_msg}")
def test_burn_efuse(self):
self.espefuse_py("burn_efuse -h")
if arg_chip == "esp32":
self.espefuse_py(
"burn_efuse \
CHIP_VER_REV2 1 \
DISABLE_DL_ENCRYPT 1 \
CONSOLE_DEBUG_DISABLE 1"
)
blk1 = "BLOCK1"
blk2 = "BLOCK2"
elif arg_chip == "esp32c2":
self.espefuse_py(
"burn_efuse \
XTS_KEY_LENGTH_256 1 \
UART_PRINT_CONTROL 1 \
FORCE_SEND_RESUME 1"
)
blk1 = "BLOCK_KEY0"
blk2 = None
else:
self.espefuse_py(
"burn_efuse \
SECURE_BOOT_EN 1 \
UART_PRINT_CONTROL 1"
)
self.espefuse_py(
"burn_efuse \
OPTIONAL_UNIQUE_ID 0x2328ad5ac9145f698f843a26d6eae168",
check_msg="-> 0x2328ad5ac9145f698f843a26d6eae168",
)
output = self.espefuse_py("summary -d")
assert (
"read_regs: d6eae168 8f843a26 c9145f69 2328ad5a "
"00000000 00000000 00000000 00000000"
) in output
assert "= 68 e1 ea d6 26 3a 84 8f 69 5f 14 c9 5a ad 28 23 R/W" in output
efuse_from_blk2 = "BLK_VERSION_MAJOR"
if arg_chip == "esp32s2":
efuse_from_blk2 = "BLK_VERSION_MINOR"
if arg_chip != "esp32c6":
self.espefuse_py(
f"burn_efuse {efuse_from_blk2} 1",
check_msg="Burn into BLOCK_SYS_DATA is forbidden "
"(RS coding scheme does not allow this).",
ret_code=2,
)
blk1 = "BLOCK_KEY1"
blk2 = "BLOCK_KEY2"
output = self.espefuse_py(
f"burn_efuse {blk1}"
+ " 0x00010203040506070809111111111111111111111111111111110000112233FF"
)
assert (
"-> 0x00010203040506070809111111111111111111111111111111110000112233ff"
in output
)
output = self.espefuse_py("summary -d")
assert (
"read_regs: 112233ff 11110000 11111111 11111111 "
"11111111 08091111 04050607 00010203"
) in output
assert (
"= ff 33 22 11 00 00 11 11 11 11 11 11 11 11 11 11 "
"11 11 11 11 11 11 09 08 07 06 05 04 03 02 01 00 R/W"
) in output
if blk2 is not None:
output = self.espefuse_py(
f"burn_efuse {blk2}"
+ " 00010203040506070809111111111111111111111111111111110000112233FF"
)
assert (
"-> 0xff33221100001111111111111111111111111111111109080706050403020100"
in output
)
output = self.espefuse_py("summary -d")
assert (
"read_regs: 03020100 07060504 11110908 11111111 "
"11111111 11111111 00001111 ff332211"
) in output
assert (
"= 00 01 02 03 04 05 06 07 08 09 11 11 11 11 11 11 "
"11 11 11 11 11 11 11 11 11 11 00 00 11 22 33 ff R/W"
) in output
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_efuse_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py("burn_efuse BLK3_PART_RESERVE 1")
self.espefuse_py("burn_efuse ADC1_TP_LOW 50")
self.espefuse_py(
"burn_efuse ADC1_TP_HIGH 55",
check_msg="Burn into BLOCK3 is forbidden "
"(3/4 coding scheme does not allow this)",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_efuse_with_34_coding_scheme2(self):
self._set_34_coding_scheme()
self.espefuse_py("burn_efuse BLK3_PART_RESERVE 1")
self.espefuse_py(
"burn_efuse \
ADC1_TP_LOW 50 \
ADC1_TP_HIGH 55 \
ADC2_TP_LOW 40 \
ADC2_TP_HIGH 45"
)
class TestBurnKeyCommands(EfuseTestCase):
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32-only")
def test_burn_key_3_key_blocks(self):
self.espefuse_py("burn_key -h")
self.espefuse_py(
f"burn_key BLOCK1 {IMAGES_DIR}/192bit",
check_msg="A fatal error occurred: Incorrect key file size 24. "
"Key file must be 32 bytes (256 bits) of raw binary key data.",
ret_code=2,
)
self.espefuse_py(
f"burn_key \
BLOCK1 {IMAGES_DIR}/256bit \
BLOCK2 {IMAGES_DIR}/256bit_1 \
BLOCK3 {IMAGES_DIR}/256bit_2 --no-protect-key"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_2")
self.espefuse_py(
f"burn_key \
BLOCK1 {IMAGES_DIR}/256bit \
BLOCK2 {IMAGES_DIR}/256bit_1 \
BLOCK3 {IMAGES_DIR}/256bit_2"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_2")
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only")
def test_burn_key_1_key_block(self):
self.espefuse_py("burn_key -h")
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit XTS_AES_128_KEY",
check_msg="A fatal error occurred: Incorrect key file size 16. "
"Key file must be 32 bytes (256 bits) of raw binary key data.",
ret_code=2,
)
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/256bit XTS_AES_128_KEY --no-read-protect"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit", reverse_order=True)
self.espefuse_py(f"burn_key BLOCK_KEY0 {IMAGES_DIR}/256bit XTS_AES_128_KEY")
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"= ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? "
"?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/-"
) in output
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only")
def test_burn_key_one_key_block_with_fe_and_sb_keys(self):
self.espefuse_py("burn_key -h")
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/256bit XTS_AES_128_KEY \
BLOCK_KEY0 {IMAGES_DIR}/128bit_key SECURE_BOOT_DIGEST",
check_msg="A fatal error occurred: These keypurposes are incompatible "
"['XTS_AES_128_KEY', 'SECURE_BOOT_DIGEST']",
ret_code=2,
)
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit_key "
f"XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS "
f"BLOCK_KEY0 {IMAGES_DIR}/128bit_key SECURE_BOOT_DIGEST --no-read-protect"
)
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: 0c0d0e0f 08090a0b 04050607 00010203 "
"03020100 07060504 0b0a0908 0f0e0d0c"
) in output
self.espefuse_py(
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit_key "
"XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS "
f"BLOCK_KEY0 {IMAGES_DIR}/128bit_key SECURE_BOOT_DIGEST"
)
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: 00000000 00000000 00000000 00000000 "
"03020100 07060504 0b0a0908 0f0e0d0c"
) in output
assert (
"= ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? "
"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f -/-"
) in output
assert "= ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/-" in output
assert "= 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f R/-" in output
@pytest.mark.skipif(
arg_chip
not in [
"esp32s2",
"esp32s3",
"esp32s3beta1",
"esp32c3",
"esp32h2beta1",
"esp32c6",
"esp32h2",
],
reason="Only chips with 6 keys",
)
def test_burn_key_with_6_keys(self):
cmd = f"burn_key \
BLOCK_KEY0 {IMAGES_DIR}/256bit XTS_AES_256_KEY_1 \
BLOCK_KEY1 {IMAGES_DIR}/256bit_1 XTS_AES_256_KEY_2 \
BLOCK_KEY2 {IMAGES_DIR}/256bit_2 XTS_AES_128_KEY"
if arg_chip in ["esp32c3", "esp32c6"] or arg_chip in [
"esp32h2",
"esp32h2beta1",
]:
cmd = cmd.replace("XTS_AES_256_KEY_1", "XTS_AES_128_KEY")
cmd = cmd.replace("XTS_AES_256_KEY_2", "XTS_AES_128_KEY")
self.espefuse_py(cmd + " --no-read-protect --no-write-protect")
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit", reverse_order=True)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_2", reverse_order=True
)
self.espefuse_py(cmd)
output = self.espefuse_py("summary -d")
assert (
"[4 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[5 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[6 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
self.espefuse_py(
f"burn_key \
BLOCK_KEY3 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST0 \
BLOCK_KEY4 {IMAGES_DIR}/256bit_1 SECURE_BOOT_DIGEST1 \
BLOCK_KEY5 {IMAGES_DIR}/256bit_2 SECURE_BOOT_DIGEST2"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_2")
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_key_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py(
f"burn_key BLOCK1 {IMAGES_DIR}/256bit",
check_msg="A fatal error occurred: Incorrect key file size 32. "
"Key file must be 24 bytes (192 bits) of raw binary key data.",
ret_code=2,
)
self.espefuse_py(
f"burn_key \
BLOCK1 {IMAGES_DIR}/192bit \
BLOCK2 {IMAGES_DIR}/192bit_1 \
BLOCK3 {IMAGES_DIR}/192bit_2 --no-protect-key"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_2")
self.espefuse_py(
f"burn_key \
BLOCK1 {IMAGES_DIR}/192bit \
BLOCK2 {IMAGES_DIR}/192bit_1 \
BLOCK3 {IMAGES_DIR}/192bit_2"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_2")
@pytest.mark.skipif(
arg_chip not in ["esp32s2", "esp32s3"],
reason="512 bit keys are only supported on ESP32-S2 and S3",
)
def test_burn_key_512bit(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY0 {IMAGES_DIR}/256bit_1_256bit_2_combined \
XTS_AES_256_KEY --no-read-protect --no-write-protect"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_2", reverse_order=True
)
@pytest.mark.skipif(
arg_chip not in ["esp32s2", "esp32s3"],
reason="512 bit keys are only supported on ESP32-S2 and S3",
)
def test_burn_key_512bit_non_consecutive_blocks(self):
# Burn efuses seperately to test different kinds
# of "key used" detection criteria
self.espefuse_py(
f"burn_key \
BLOCK_KEY2 {IMAGES_DIR}/256bit XTS_AES_128_KEY"
)
self.espefuse_py(
f"burn_key \
BLOCK_KEY4 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST0"
)
self.espefuse_py(
f"burn_key \
BLOCK_KEY1 {IMAGES_DIR}/256bit_1_256bit_2_combined \
XTS_AES_256_KEY --no-read-protect --no-write-protect"
)
self.espefuse_py(
f"burn_key \
BLOCK_KEY5 {IMAGES_DIR}/256bit USER --no-read-protect --no-write-protect"
)
# Second half of key should burn to first available key block (BLOCK_KEY5)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_2", reverse_order=True
)
assert (
"[5 ] read_regs: bcbd11bf b8b9babb b4b5b6b7 "
"b0b1b2b3 acadaeaf a8a9aaab a4a5a6a7 11a1a2a3"
) in output
assert (
"[7 ] read_regs: bcbd22bf b8b9babb b4b5b6b7 "
"b0b1b2b3 acadaeaf a8a9aaab a4a5a6a7 22a1a2a3"
) in output
@pytest.mark.skipif(
arg_chip not in ["esp32s2", "esp32s3"],
reason="512 bit keys are only supported on ESP32-S2 and S3",
)
def test_burn_key_512bit_non_consecutive_blocks_loop_around(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY2 {IMAGES_DIR}/256bit XTS_AES_128_KEY \
BLOCK_KEY3 {IMAGES_DIR}/256bit USER \
BLOCK_KEY4 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST0 \
BLOCK_KEY5 {IMAGES_DIR}/256bit SECURE_BOOT_DIGEST1 \
BLOCK_KEY1 {IMAGES_DIR}/256bit_1_256bit_2_combined \
XTS_AES_256_KEY --no-read-protect --no-write-protect"
)
# Second half of key should burn to first available key block (BLOCK_KEY0)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_2", reverse_order=True
)
assert (
"[5 ] read_regs: bcbd11bf b8b9babb b4b5b6b7 b0b1b2b3 "
"acadaeaf a8a9aaab a4a5a6a7 11a1a2a3"
) in output
assert (
"[4 ] read_regs: bcbd22bf b8b9babb b4b5b6b7 b0b1b2b3 "
"acadaeaf a8a9aaab a4a5a6a7 22a1a2a3"
) in output
@pytest.mark.skipif(arg_chip != "esp32h2", reason="Only for ESP32-H2 chips")
def test_burn_key_ecdsa_key(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY0 {S_IMAGES_DIR}/ecdsa192_secure_boot_signing_key_v2.pem \
ECDSA_KEY \
BLOCK_KEY1 {S_IMAGES_DIR}/ecdsa256_secure_boot_signing_key_v2.pem \
ECDSA_KEY"
)
output = self.espefuse_py("summary -d")
assert 2 == output.count(
"= ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? "
"?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/-"
)
assert (
"[4 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[5 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
@pytest.mark.skipif(arg_chip != "esp32h2", reason="Only for ESP32-H2 chips")
def test_burn_key_ecdsa_key_check_byte_order(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY0 {S_IMAGES_DIR}/ecdsa192_secure_boot_signing_key_v2.pem \
ECDSA_KEY \
BLOCK_KEY1 {S_IMAGES_DIR}/ecdsa256_secure_boot_signing_key_v2.pem \
ECDSA_KEY \
--no-read-protect"
)
output = self.espefuse_py("summary -d")
assert (
"= c8 c4 5d 62 9e 05 05 bd cb 04 a4 7c 06 f5 86 14 "
"cb 23 81 23 95 b7 71 4f 00 00 00 00 00 00 00 00 R/-"
) in output
assert (
"= fc 6b ec 75 64 37 7d 3b 88 8d 34 05 ed 91 06 1b "
"38 c2 50 84 7a 08 9d c3 66 6a 06 90 23 8b 54 b4 R/-"
) in output
assert (
"[4 ] read_regs: 625dc4c8 bd05059e 7ca404cb 1486f506 "
"238123cb 4f71b795 00000000 00000000"
) in output
assert (
"[5 ] read_regs: 75ec6bfc 3b7d3764 05348d88 1b0691ed "
"8450c238 c39d087a 90066a66 b4548b23"
) in output
class TestBurnBlockDataCommands(EfuseTestCase):
def test_burn_block_data_check_args(self):
self.espefuse_py("burn_block_data -h")
blk0 = "BLOCK0"
blk1 = "BLOCK1"
self.espefuse_py(
f"burn_block_data {blk0} {IMAGES_DIR}/224bit {blk1}",
check_msg="A fatal error occurred: "
"The number of block_name (2) and datafile (1) should be the same.",
ret_code=2,
)
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32-only")
def test_burn_block_data_with_3_key_blocks(self):
self.espefuse_py(
f"burn_block_data \
BLOCK0 {IMAGES_DIR}/224bit \
BLOCK3 {IMAGES_DIR}/256bit"
)
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac "
"b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc"
) in output
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.espefuse_py(
f"burn_block_data \
BLOCK2 {IMAGES_DIR}/256bit_1"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/256bit_1"
)
self.espefuse_py(
f"burn_block_data \
BLOCK1 {IMAGES_DIR}/256bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/256bit_2"
)
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only")
def test_burn_block_data_with_1_key_block(self):
self.espefuse_py(
f"burn_block_data \
BLOCK0 {IMAGES_DIR}/64bit \
BLOCK1 {IMAGES_DIR}/96bit \
BLOCK2 {IMAGES_DIR}/256bit \
BLOCK3 {IMAGES_DIR}/256bit"
)
output = self.espefuse_py("summary -d")
assert "[0 ] read_regs: 00000001 0000000c" in output
assert "[1 ] read_regs: 03020100 07060504 000a0908" in output
assert (
"[2 ] read_regs: a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac "
"b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc"
) in output
assert (
"[3 ] read_regs: a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac "
"b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc"
) in output
@pytest.mark.skipif(
arg_chip
not in [
"esp32s2",
"esp32s3",
"esp32s3beta1",
"esp32c3",
"esp32h2beta1",
"esp32c6",
"esp32h2",
],
reason="Only chip with 6 keys",
)
def test_burn_block_data_with_6_keys(self):
self.espefuse_py(
f"burn_block_data \
BLOCK0 {IMAGES_DIR}/192bit \
BLOCK3 {IMAGES_DIR}/256bit"
)
output = self.espefuse_py("summary -d")
assert (
"[0 ] read_regs: 00000000 07060500 00000908 00000000 13000000 00161514"
in output
)
assert (
"[3 ] read_regs: a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac "
"b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc"
) in output
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.espefuse_py(
f"burn_block_data \
BLOCK10 {IMAGES_DIR}/256bit_1"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/256bit_1"
)
self.espefuse_py(
f"burn_block_data \
BLOCK1 {IMAGES_DIR}/192bit \
BLOCK5 {IMAGES_DIR}/256bit_1 \
BLOCK6 {IMAGES_DIR}/256bit_2"
)
output = self.espefuse_py("summary -d")
assert (
"[1 ] read_regs: 00000000 07060500 00000908 00000000 13000000 00161514"
in output
)
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_1", 2)
self.check_data_block_in_log(output, f"{IMAGES_DIR}/256bit_2")
def test_burn_block_data_check_errors(self):
self.espefuse_py(
f"burn_block_data \
BLOCK2 {IMAGES_DIR}/192bit \
BLOCK2 {IMAGES_DIR}/192bit_1",
check_msg="A fatal error occurred: Found repeated",
ret_code=2,
)
self.espefuse_py(
f"burn_block_data \
BLOCK2 {IMAGES_DIR}/192bit \
BLOCK3 {IMAGES_DIR}/192bit_1 \
--offset 4",
check_msg="A fatal error occurred: "
"The 'offset' option is not applicable when a few blocks are passed.",
ret_code=2,
)
self.espefuse_py(
f"burn_block_data BLOCK0 {IMAGES_DIR}/192bit --offset 33",
check_msg="A fatal error occurred: Invalid offset: the block0 only holds",
ret_code=2,
)
self.espefuse_py(
f"burn_block_data BLOCK0 {IMAGES_DIR}/256bit --offset 4",
check_msg="A fatal error occurred: Data does not fit:",
ret_code=2,
)
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32-only")
def test_burn_block_data_with_offset_for_3_key_blocks(self):
offset = 1
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK0 {IMAGES_DIR}/192bit"
)
offset = 4
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK1 {IMAGES_DIR}/192bit_1"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_1", offset=offset
)
offset = 6
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK2 {IMAGES_DIR}/192bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_2", offset=offset
)
offset = 8
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK3 {IMAGES_DIR}/192bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_2", offset=offset
)
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only")
def test_burn_block_data_with_offset_1_key_block(self):
offset = 4
self.espefuse_py(f"burn_block_data --offset {offset} BLOCK1 {IMAGES_DIR}/92bit")
output = self.espefuse_py("summary -d")
assert "[1 ] read_regs: 00000000 03020100 00060504" in output
offset = 6
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK2 {IMAGES_DIR}/192bit_1"
)
output = self.espefuse_py("summary -d")
assert (
"[2 ] read_regs: 00000000 00110000 05000000 09080706 "
"0d0c0b0a 11100f0e 15141312 00002116"
) in output
offset = 8
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK3 {IMAGES_DIR}/192bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_2", offset=offset
)
@pytest.mark.skipif(
arg_chip
not in [
"esp32s2",
"esp32s3",
"esp32s3beta1",
"esp32c3",
"esp32h2beta1",
"esp32c6",
"esp32h2",
],
reason="Only chips with 6 keys",
)
def test_burn_block_data_with_offset_6_keys(self):
offset = 4
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK_KEY0 {IMAGES_DIR}/192bit_1"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_1", offset=offset
)
offset = 6
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK_KEY1 {IMAGES_DIR}/192bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_2", offset=offset
)
offset = 8
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK_KEY2 {IMAGES_DIR}/192bit_2"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/192bit_2", offset=offset
)
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_block_data_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py(
f"burn_block_data BLOCK1 {IMAGES_DIR}/256bit",
check_msg="A fatal error occurred: Data does not fit: "
"the block1 size is 24 bytes, data file is 32 bytes, offset 0",
ret_code=2,
)
self.espefuse_py(
f"burn_block_data \
BLOCK1 {IMAGES_DIR}/192bit \
BLOCK2 {IMAGES_DIR}/192bit_1 \
BLOCK3 {IMAGES_DIR}/192bit_2"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_1")
self.check_data_block_in_log(output, f"{IMAGES_DIR}/192bit_2")
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_block_data_with_34_coding_scheme_and_offset(self):
self._set_34_coding_scheme()
offset = 4
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK1 {IMAGES_DIR}/128bit"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/128bit", offset=offset
)
offset = 6
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK2 {IMAGES_DIR}/128bit"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/128bit", offset=offset
)
offset = 8
self.espefuse_py(
f"burn_block_data --offset {offset} BLOCK3 {IMAGES_DIR}/128bit"
)
self.check_data_block_in_log(
self.espefuse_py("summary -d"), f"{IMAGES_DIR}/128bit", offset=offset
)
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32-only, supports 2 key blocks")
class TestBurnKeyDigestCommandsEsp32(EfuseTestCase):
def test_burn_key_digest(self):
self.espefuse_py("burn_key_digest -h")
esp = self.get_esptool()
if esp.get_chip_revision() >= 300:
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem"
)
output = self.espefuse_py("summary -d")
assert (
" = cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 "
"22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63 R/-"
) in output
else:
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem",
check_msg="Incorrect chip revision for Secure boot v2.",
ret_code=2,
)
def test_burn_key_from_digest(self):
# python espsecure.py digest_rsa_public_key
# --keyfile test/{S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem
# -o {S_IMAGES_DIR}/rsa_public_key_digest.bin
self.espefuse_py(
f"burn_key \
BLOCK2 {S_IMAGES_DIR}/rsa_public_key_digest.bin --no-protect-key"
)
output = self.espefuse_py("summary -d")
assert 1 == output.count(
" = cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 "
"22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63 R/W"
)
def test_burn_key_digest_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem",
check_msg="burn_key_digest only works with 'None' coding scheme",
ret_code=2,
)
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only, supports 1 key block")
class TestBurnKeyDigestCommandsEsp32C2(EfuseTestCase):
def test_burn_key_digest1(self):
# python espsecure.py generate_signing_key --version 2
# secure_images/ecdsa192_secure_boot_signing_key_v2.pem --scheme ecdsa192
self.espefuse_py("burn_key_digest -h")
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/ecdsa192_secure_boot_signing_key_v2.pem"
)
output = self.espefuse_py("summary -d")
assert " = 1e 3d 15 16 96 ca 7f 22 a6 e8 8b d5 27 a0 3b 3b R/-" in output
assert (
" = 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "
"1e 3d 15 16 96 ca 7f 22 a6 e8 8b d5 27 a0 3b 3b R/-"
) in output
def test_burn_key_digest2(self):
# python espsecure.py generate_signing_key --version 2
# secure_images/ecdsa256_secure_boot_signing_key_v2.pem --scheme ecdsa256
self.espefuse_py("burn_key_digest -h")
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/ecdsa256_secure_boot_signing_key_v2.pem"
)
output = self.espefuse_py("summary -d")
assert " = bf 0f 6a f6 8b d3 6d 8b 53 b3 da a9 33 f6 0a 04 R/-" in output
assert (
" = 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "
"bf 0f 6a f6 8b d3 6d 8b 53 b3 da a9 33 f6 0a 04 R/-"
) in output
def test_burn_key_from_digest1(self):
# python espsecure.py digest_sbv2_public_key --keyfile
# secure_images/ecdsa192_secure_boot_signing_key_v2.pem
# -o secure_images/ecdsa192_public_key_digest_v2.bin
self.espefuse_py(
"burn_key BLOCK_KEY0 "
f"{S_IMAGES_DIR}/ecdsa192_public_key_digest_v2.bin SECURE_BOOT_DIGEST"
)
output = self.espefuse_py("summary -d")
assert (
" = 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "
"1e 3d 15 16 96 ca 7f 22 a6 e8 8b d5 27 a0 3b 3b R/-"
) in output
def test_burn_key_from_digest2(self):
# python espsecure.py digest_sbv2_public_key --keyfile
# secure_images/ecdsa256_secure_boot_signing_key_v2.pem
# -o secure_images/ecdsa256_public_key_digest_v2.bin
self.espefuse_py(
"burn_key BLOCK_KEY0 "
f"{S_IMAGES_DIR}/ecdsa256_public_key_digest_v2.bin SECURE_BOOT_DIGEST"
)
output = self.espefuse_py("summary -d")
assert (
" = 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "
"bf 0f 6a f6 8b d3 6d 8b 53 b3 da a9 33 f6 0a 04 R/-"
) in output
@pytest.mark.skipif(
arg_chip
not in [
"esp32s2",
"esp32s3",
"esp32s3beta1",
"esp32c3",
"esp32h2beta1",
"esp32c6",
"esp32h2",
],
reason="Supports 6 key blocks",
)
class TestBurnKeyDigestCommands(EfuseTestCase):
def test_burn_key_digest(self):
self.espefuse_py("burn_key_digest -h")
self.espefuse_py(
f"burn_key_digest \
BLOCK_KEY0 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST0 \
BLOCK_KEY1 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key2.pem SECURE_BOOT_DIGEST1 \
BLOCK_KEY2 ",
check_msg="A fatal error occurred: The number of blocks (3), "
"datafile (2) and keypurpose (2) should be the same.",
ret_code=2,
)
self.espefuse_py(
f"burn_key_digest \
BLOCK_KEY0 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST0 \
BLOCK_KEY1 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key2.pem SECURE_BOOT_DIGEST1 \
BLOCK_KEY2 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key2.pem SECURE_BOOT_DIGEST2"
)
output = self.espefuse_py("summary -d")
assert 1 == output.count(
" = cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 "
"22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63 R/-"
)
assert 2 == output.count(
" = 90 1a 74 09 23 8d 52 d4 cb f9 6f 56 3f b3 f4 29 "
"6d ab d6 6a 33 f5 3b 15 ee cd 8c b3 e7 ec 45 d3 R/-"
)
def test_burn_key_from_digest(self):
# python espsecure.py digest_rsa_public_key
# --keyfile test/secure_images/rsa_secure_boot_signing_key.pem
# -o secure_images/rsa_public_key_digest.bin
self.espefuse_py(
f"burn_key \
BLOCK_KEY0 {S_IMAGES_DIR}/rsa_public_key_digest.bin SECURE_BOOT_DIGEST0"
)
output = self.espefuse_py("summary -d")
assert 1 == output.count(
" = cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 "
"22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63 R/-"
)
self.espefuse_py(
f"burn_key_digest \
BLOCK_KEY1 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST1"
)
output = self.espefuse_py("summary -d")
assert 2 == output.count(
" = cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 "
"22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63 R/-"
)
class TestBurnBitCommands(EfuseTestCase):
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32-only")
def test_burn_bit_for_chips_with_3_key_blocks(self):
self.espefuse_py("burn_bit -h")
self.espefuse_py("burn_bit BLOCK3 0 1 2 4 8 16 32 64 96 128 160 192 224 255")
self.espefuse_py(
"summary",
check_msg="17 01 01 00 01 00 00 00 01 00 00 00 01 00 00 "
"00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 80",
)
self.espefuse_py(
"burn_bit BLOCK3 3 5 6 7 9 10 11 12 13 14 15 31 63 95 127 159 191 223 254"
)
self.espefuse_py(
"summary",
check_msg="ff ff 01 80 01 00 00 80 01 00 00 80 01 "
"00 00 80 01 00 00 80 01 00 00 80 01 00 00 80 01 00 00 c0",
)
@pytest.mark.skipif(arg_chip != "esp32c2", reason="ESP32-C2-only")
def test_burn_bit_for_chips_with_1_key_block(self):
self.espefuse_py("burn_bit -h")
self.espefuse_py("burn_bit BLOCK3 0 1 2 4 8 16 32 64 96 128 160 192 224 255")
self.espefuse_py(
"summary",
check_msg="17 01 01 00 01 00 00 00 01 00 00 00 01 00 "
"00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 80",
)
self.espefuse_py(
"burn_bit BLOCK3 100",
check_msg="Burn into BLOCK_KEY0 is forbidden "
"(RS coding scheme does not allow this)",
ret_code=2,
)
self.espefuse_py("burn_bit BLOCK0 0 1 2")
self.espefuse_py("summary", check_msg="[0 ] read_regs: 00000007 00000000")
@pytest.mark.skipif(
arg_chip
not in [
"esp32s2",
"esp32s3",
"esp32s3beta1",
"esp32c3",
"esp32h2beta1",
"esp32c6",
"esp32h2",
],
reason="Only chip with 6 keys",
)
def test_burn_bit_for_chips_with_6_key_blocks(self):
self.espefuse_py("burn_bit -h")
self.espefuse_py("burn_bit BLOCK3 0 1 2 4 8 16 32 64 96 128 160 192 224 255")
self.espefuse_py(
"summary",
check_msg="17 01 01 00 01 00 00 00 01 00 00 00 01 00 "
"00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 80",
)
self.espefuse_py(
"burn_bit BLOCK3 100",
check_msg="Burn into BLOCK_USR_DATA is forbidden "
"(RS coding scheme does not allow this)",
ret_code=2,
)
self.espefuse_py("burn_bit BLOCK0 13")
self.espefuse_py(
"summary",
check_msg="[0 ] read_regs: 00002000 00000000 00000000 "
"00000000 00000000 00000000",
)
self.espefuse_py("burn_bit BLOCK0 24")
self.espefuse_py(
"summary",
check_msg="[0 ] read_regs: 01002000 00000000 00000000 "
"00000000 00000000 00000000",
)
@pytest.mark.skipif(
arg_chip != "esp32", reason="3/4 coding scheme is only in esp32"
)
def test_burn_bit_with_34_coding_scheme(self):
self._set_34_coding_scheme()
self.espefuse_py("burn_bit BLOCK3 0 1 2 4 8 16 32 64 96 128 160 191")
self.espefuse_py(
"summary",
check_msg="17 01 01 00 01 00 00 00 01 00 00 00 01 00 "
"00 00 01 00 00 00 01 00 00 80",
)
self.espefuse_py(
"burn_bit BLOCK3 17",
check_msg="Burn into BLOCK3 is forbidden "
"(3/4 coding scheme does not allow this).",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip != "esp32", reason="Tests are only for esp32. (TODO: add for all chips)"
)
class TestByteOrderBurnKeyCommand(EfuseTestCase):
def test_1_secure_boot_v1(self):
if arg_chip == "esp32":
self.espefuse_py(
f"burn_key \
flash_encryption {IMAGES_DIR}/256bit \
secure_boot_v1 {IMAGES_DIR}/256bit_1 --no-protect-key"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=True
)
self.espefuse_py(
f"burn_key \
flash_encryption {IMAGES_DIR}/256bit \
secure_boot_v1 {IMAGES_DIR}/256bit_1"
)
output = self.espefuse_py("summary -d")
assert (
"[1 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[2 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[3 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
def test_2_secure_boot_v1(self):
if arg_chip == "esp32":
self.espefuse_py(
f"burn_key \
flash_encryption {IMAGES_DIR}/256bit \
secure_boot_v2 {IMAGES_DIR}/256bit_1 --no-protect-key"
)
output = self.espefuse_py("summary -d")
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit", reverse_order=True
)
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=False
)
self.espefuse_py(
f"burn_key \
flash_encryption {IMAGES_DIR}/256bit \
secure_boot_v2 {IMAGES_DIR}/256bit_1"
)
output = self.espefuse_py("summary -d")
assert (
"[1 ] read_regs: 00000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
self.check_data_block_in_log(
output, f"{IMAGES_DIR}/256bit_1", reverse_order=False
)
class TestExecuteScriptsCommands(EfuseTestCase):
@classmethod
def setup_class(self):
# Save the current working directory to be resotred later
self.stored_dir = os.getcwd()
@classmethod
def teardown_class(self):
# Restore the stored working directory
os.chdir(self.stored_dir)
@pytest.mark.skipif(arg_chip == "esp32c2", reason="TODO: Add tests for esp32c2")
def test_execute_scripts_with_check_that_only_one_burn(self):
self.espefuse_py("execute_scripts -h")
name = arg_chip if arg_chip in ["esp32", "esp32c2"] else "esp32xx"
os.chdir(os.path.join(TEST_DIR, "efuse_scripts", name))
self.espefuse_py("execute_scripts execute_efuse_script2.py")
@pytest.mark.skipif(arg_chip == "esp32c2", reason="TODO: Add tests for esp32c2")
def test_execute_scripts_with_check(self):
self.espefuse_py("execute_scripts -h")
name = arg_chip if arg_chip in ["esp32", "esp32c2"] else "esp32xx"
os.chdir(os.path.join(TEST_DIR, "efuse_scripts", name))
self.espefuse_py("execute_scripts execute_efuse_script.py")
def test_execute_scripts_with_index_and_config(self):
os.chdir(TEST_DIR)
if arg_chip in ["esp32", "esp32c2"]:
cmd = f"execute_scripts {EFUSE_S_DIR}/efuse_burn1.py --index 10 \
--configfiles {EFUSE_S_DIR}/esp32/config1.json"
else:
cmd = f"execute_scripts {EFUSE_S_DIR}/efuse_burn1.py --index 10 \
--configfiles {EFUSE_S_DIR}/esp32xx/config1.json"
self.espefuse_py(cmd)
output = self.espefuse_py("summary -d")
if arg_chip in ["esp32", "esp32c2"]:
assert (
"[3 ] read_regs: e00007ff 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
else:
assert (
"[8 ] read_regs: e00007ff 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
def test_execute_scripts_nesting(self):
os.chdir(TEST_DIR)
if arg_chip in ["esp32", "esp32c2"]:
cmd = f"execute_scripts {EFUSE_S_DIR}/efuse_burn2.py --index 28 \
--configfiles {EFUSE_S_DIR}/esp32/config2.json"
else:
cmd = f"execute_scripts {EFUSE_S_DIR}/efuse_burn2.py --index 28 \
--configfiles {EFUSE_S_DIR}/esp32xx/config2.json"
self.espefuse_py(cmd)
output = self.espefuse_py("summary -d")
if arg_chip in ["esp32", "esp32c2"]:
assert (
"[2 ] read_regs: 10000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[3 ] read_regs: ffffffff 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
else:
assert (
"[7 ] read_regs: 10000000 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
assert (
"[8 ] read_regs: ffffffff 00000000 00000000 00000000 "
"00000000 00000000 00000000 00000000"
) in output
class TestMultipleCommands(EfuseTestCase):
def test_multiple_cmds_help(self):
if arg_chip == "esp32c2":
command1 = (
f"burn_key_digest {S_IMAGES_DIR}"
"/ecdsa256_secure_boot_signing_key_v2.pem"
)
command2 = (
f"burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit_key "
"XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS"
)
elif arg_chip == "esp32":
command1 = f"burn_key_digest {S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem"
command2 = f"burn_key flash_encryption {IMAGES_DIR}/256bit"
else:
command1 = f"burn_key_digest BLOCK_KEY0 \
{S_IMAGES_DIR}/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST0"
command2 = f"burn_key BLOCK_KEY0 \
{S_IMAGES_DIR}/rsa_public_key_digest.bin SECURE_BOOT_DIGEST0"
self.espefuse_py(
f"-h {command1} {command2}",
check_msg="usage: __main__.py [-h]",
)
self.espefuse_py(
f"{command1} -h {command2}",
check_msg="usage: __main__.py burn_key_digest [-h]",
)
self.espefuse_py(
f"{command1} {command2} -h",
check_msg="usage: __main__.py burn_key [-h]",
)
@pytest.mark.skipif(
arg_chip != "esp32c2", reason="For this chip, FE and SB keys go into one BLOCK"
)
def test_1_esp32c2(self):
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/ecdsa256_secure_boot_signing_key_v2.pem \
burn_key BLOCK_KEY0 {IMAGES_DIR}/128bit_key \
XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS --no-read-protect \
summary"
)
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: 0c0d0e0f 08090a0b 04050607 00010203 "
"f66a0fbf 8b6dd38b a9dab353 040af633"
) in output
assert " = 0f 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00 R/-" in output
assert " = bf 0f 6a f6 8b d3 6d 8b 53 b3 da a9 33 f6 0a 04 R/-" in output
@pytest.mark.skipif(
arg_chip != "esp32c2", reason="For this chip, FE and SB keys go into one BLOCK"
)
def test_2_esp32c2(self):
self.espefuse_py(
f"burn_key_digest {S_IMAGES_DIR}/ecdsa256_secure_boot_signing_key_v2.pem \
burn_key BLOCK_KEY0 \
{IMAGES_DIR}/128bit_key XTS_AES_128_KEY_DERIVED_FROM_128_EFUSE_BITS \
summary"
)
output = self.espefuse_py("summary -d")
assert (
"[3 ] read_regs: 00000000 00000000 00000000 00000000 "
"f66a0fbf 8b6dd38b a9dab353 040af633"
) in output
assert " = ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/-" in output
assert " = bf 0f 6a f6 8b d3 6d 8b 53 b3 da a9 33 f6 0a 04 R/-" in output
def test_burn_bit(self):
if arg_chip == "esp32":
self._set_34_coding_scheme()
self.espefuse_py(
"burn_bit BLOCK2 0 1 2 3 \
burn_bit BLOCK2 4 5 6 7 \
burn_bit BLOCK2 8 9 10 11 \
burn_bit BLOCK2 12 13 14 15 \
summary"
)
output = self.espefuse_py("summary -d")
assert "[2 ] read_regs: 0000ffff 00000000" in output
def test_not_burn_cmds(self):
self.espefuse_py(
"summary \
dump \
get_custom_mac \
adc_info \
check_error"
)
@pytest.mark.skipif(
arg_chip not in ["esp32c3", "esp32c6", "esp32h2", "esp32s3"],
reason="These chips have a hardware bug that limits the use of the KEY5",
)
class TestKeyPurposes(EfuseTestCase):
def test_burn_xts_aes_key_purpose(self):
self.espefuse_py(
"burn_efuse KEY_PURPOSE_5 XTS_AES_128_KEY",
check_msg="A fatal error occurred: "
"KEY_PURPOSE_5 can not have XTS_AES_128_KEY "
"key due to a hardware bug (please see TRM for more details)",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip != "esp32h2", reason="esp32h2 can not have ECDSA key in KEY5"
)
def test_burn_ecdsa_key_purpose(self):
self.espefuse_py(
"burn_efuse KEY_PURPOSE_5 ECDSA_KEY",
check_msg="A fatal error occurred: "
"KEY_PURPOSE_5 can not have ECDSA_KEY "
"key due to a hardware bug (please see TRM for more details)",
ret_code=2,
)
def test_burn_xts_aes_key(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY5 {IMAGES_DIR}/256bit XTS_AES_128_KEY",
check_msg="A fatal error occurred: "
"KEY_PURPOSE_5 can not have XTS_AES_128_KEY "
"key due to a hardware bug (please see TRM for more details)",
ret_code=2,
)
@pytest.mark.skipif(
arg_chip != "esp32h2", reason="esp32h2 can not have ECDSA key in KEY5"
)
def test_burn_ecdsa_key(self):
self.espefuse_py(
f"burn_key \
BLOCK_KEY5 {S_IMAGES_DIR}/ecdsa192_secure_boot_signing_key_v2.pem \
ECDSA_KEY",
check_msg="A fatal error occurred: "
"KEY_PURPOSE_5 can not have ECDSA_KEY "
"key due to a hardware bug (please see TRM for more details)",
ret_code=2,
)
| 74,249 | Python | .py | 1,778 | 30.940382 | 88 | 0.56524 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,578 | test_espsecure_hsm.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_espsecure_hsm.py | # Tests for espsecure.py (esp_hsm_sign.py) using the pytest framework
#
# Assumes openssl binary is in the PATH
import configparser
import os
import os.path
import sys
import tempfile
from collections import namedtuple
from conftest import need_to_install_package_err
try:
import espsecure
import pkcs11
except ImportError:
need_to_install_package_err()
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
TOKEN_PIN = "1234"
TOKEN_PIN_SO = "123456"
class EspSecureHSMTestCase:
@classmethod
def setup_class(self):
self.cleanup_files = [] # keep a list of files _open()ed by each test case
@classmethod
def teardown_class(self):
for f in self.cleanup_files:
f.close()
def _open(self, image_file):
f = open(os.path.join(TEST_DIR, "secure_images", image_file), "rb")
self.cleanup_files.append(f)
return f
def get_pkcs11lib(self):
if sys.maxsize > 2**32:
# 64-bits
WINDOWS_SOFTHSM = "c:/SoftHSM2/lib/softhsm2-x64.dll"
else:
# 32-bits
WINDOWS_SOFTHSM = "c:/SoftHSM2/lib/softhsm2.dll"
# use SoftHSM2
LIBS = [
"/usr/local/lib/softhsm/libsofthsm2.so", # macOS or local build
"/usr/lib/softhsm/libsofthsm2.so", # Debian
"/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so", # Ubuntu 16.04
WINDOWS_SOFTHSM, # Windows
]
for lib in LIBS:
if os.path.isfile(lib):
print("Using lib:", lib)
return lib
return None
# RSA-PSS token
def softhsm_setup_token(self, filename, token_label):
self.pkcs11_lib = self.get_pkcs11lib()
if self.pkcs11_lib is None:
print("PKCS11 lib does not exist")
sys.exit(-1)
lib = pkcs11.lib(self.pkcs11_lib)
token = lib.get_token(token_label=token_label)
slot = token.slot.slot_id
session = token.open(rw=True, user_pin=TOKEN_PIN)
keyID = (0x0,)
label = "Private Key for Digital Signature"
label_pubkey = "Public Key for Digital Signature"
pubTemplate = [
(pkcs11.Attribute.CLASS, pkcs11.constants.ObjectClass.PUBLIC_KEY),
(pkcs11.Attribute.TOKEN, True),
(pkcs11.Attribute.PRIVATE, False),
(pkcs11.Attribute.MODULUS_BITS, 0x0C00),
(pkcs11.Attribute.PUBLIC_EXPONENT, (0x01, 0x00, 0x01)),
(pkcs11.Attribute.ENCRYPT, True),
(pkcs11.Attribute.VERIFY, True),
(pkcs11.Attribute.VERIFY_RECOVER, True),
(pkcs11.Attribute.WRAP, True),
(pkcs11.Attribute.LABEL, label_pubkey),
(pkcs11.Attribute.ID, keyID),
]
privTemplate = [
(pkcs11.Attribute.CLASS, pkcs11.constants.ObjectClass.PRIVATE_KEY),
(pkcs11.Attribute.TOKEN, True),
(pkcs11.Attribute.PRIVATE, True),
(pkcs11.Attribute.DECRYPT, True),
(pkcs11.Attribute.SIGN, True),
(pkcs11.Attribute.SENSITIVE, True),
(pkcs11.Attribute.SIGN_RECOVER, True),
(pkcs11.Attribute.LABEL, label),
(pkcs11.Attribute.UNWRAP, True),
(pkcs11.Attribute.ID, keyID),
]
session.generate_keypair(
pkcs11.KeyType.RSA,
3072,
private_template=privTemplate,
public_template=pubTemplate,
)
# Generate HSM config file
configfile = os.path.join(TEST_DIR, "secure_images", filename)
config = configparser.ConfigParser()
section = "hsm_config"
config.add_section(section)
config.set(section, "pkcs11_lib", self.pkcs11_lib)
config.set(section, "credentials", TOKEN_PIN)
config.set(section, "slot", str(slot))
config.set(section, "label", label)
config.set(section, "label_pubkey", label_pubkey)
with open(configfile, "w") as c:
config.write(c)
session.close()
class TestSigning(EspSecureHSMTestCase):
VerifyArgs = namedtuple(
"verify_signature_args", ["version", "hsm", "hsm_config", "keyfile", "datafile"]
)
SignArgs = namedtuple(
"sign_data_args",
[
"version",
"keyfile",
"output",
"append_signatures",
"hsm",
"hsm_config",
"pub_key",
"signature",
"datafile",
],
)
def test_sign_v2_hsm(self):
# Sign using SoftHSMv2 + Verify
self.softhsm_setup_token("softhsm_v2.ini", "softhsm-test-token")
with tempfile.NamedTemporaryFile() as output_file:
args = self.SignArgs(
"2",
None,
output_file.name,
False,
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2.ini"),
None,
None,
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2",
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2.ini"),
None,
output_file,
)
espsecure.verify_signature(args)
def test_sign_v2_hsm_append_signatures_multiple_steps(self):
# Append signatures using HSM + Verify with an appended key
self.softhsm_setup_token("softhsm_v2_1.ini", "softhsm-test-token-1")
with tempfile.NamedTemporaryFile() as output_file1:
args = self.SignArgs(
"2",
None,
output_file1.name,
True,
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_1.ini"),
None,
None,
self._open("bootloader_unsigned_v2.bin"),
)
espsecure.sign_data(args)
self.softhsm_setup_token("softhsm_v2_2.ini", "softhsm-test-token-2")
with tempfile.NamedTemporaryFile() as output_file2:
args = self.SignArgs(
"2",
None,
output_file2.name,
True,
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_2.ini"),
None,
None,
self._open(output_file1.name),
)
espsecure.sign_data(args)
self.softhsm_setup_token("softhsm_v2_3.ini", "softhsm-test-token-3")
with tempfile.NamedTemporaryFile() as output_file3:
args = self.SignArgs(
"2",
None,
output_file3.name,
True,
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_3.ini"),
None,
None,
self._open(output_file2.name),
)
espsecure.sign_data(args)
args = self.VerifyArgs(
"2",
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_1.ini"),
None,
output_file3,
)
espsecure.verify_signature(args)
output_file3.seek(0)
args = self.VerifyArgs(
"2",
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_2.ini"),
None,
output_file3,
)
espsecure.verify_signature(args)
output_file3.seek(0)
args = self.VerifyArgs(
"2",
True,
os.path.join(TEST_DIR, "secure_images", "softhsm_v2_3.ini"),
None,
output_file3,
)
espsecure.verify_signature(args)
| 8,296 | Python | .py | 218 | 24.655963 | 88 | 0.514726 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,579 | test_merge_bin.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_merge_bin.py | import itertools
import os
import os.path
import subprocess
import sys
import tempfile
IMAGES_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "images")
from conftest import need_to_install_package_err
import pytest
try:
from esptool.util import byte
except ImportError:
need_to_install_package_err()
def read_image(filename):
with open(os.path.join(IMAGES_DIR, filename), "rb") as f:
return f.read()
@pytest.mark.host_test
class TestMergeBin:
def run_merge_bin(self, chip, offsets_names, options=[]):
"""Run merge_bin on a list of (offset, filename) tuples
with output to a named temporary file.
Filenames are relative to the 'test/images' directory.
Returns the contents of the merged file if successful.
"""
output_file = tempfile.NamedTemporaryFile(delete=False)
try:
output_file.close()
cmd = [
sys.executable,
"-m",
"esptool",
"--chip",
chip,
"merge_bin",
"-o",
output_file.name,
] + options
for offset, name in offsets_names:
cmd += [hex(offset), name]
print("\nExecuting {}".format(" ".join(cmd)))
output = subprocess.check_output(
cmd, cwd=IMAGES_DIR, stderr=subprocess.STDOUT
)
output = output.decode("utf-8")
print(output)
assert (
"warning" not in output.lower()
), "merge_bin should not output warnings"
with open(output_file.name, "rb") as f:
return f.read()
except subprocess.CalledProcessError as e:
print(e.output)
raise
finally:
os.unlink(output_file.name)
def assertAllFF(self, some_bytes):
# this may need some improving as the failed assert messages may be
# very long and/or useless!
assert b"\xFF" * len(some_bytes) == some_bytes
def test_simple_merge(self):
merged = self.run_merge_bin(
"esp8266",
[(0x0, "one_kb.bin"), (0x1000, "one_kb.bin"), (0x10000, "one_kb.bin")],
)
one_kb = read_image("one_kb.bin")
assert len(one_kb) == 0x400
assert len(merged) == 0x10400
assert merged[:0x400] == one_kb
assert merged[0x1000:0x1400] == one_kb
assert merged[0x10000:] == one_kb
self.assertAllFF(merged[0x400:0x1000])
self.assertAllFF(merged[0x1400:0x10000])
def test_args_out_of_order(self):
# no matter which order we supply arguments, the output should be the same
args = [(0x0, "one_kb.bin"), (0x1000, "one_kb.bin"), (0x10000, "one_kb.bin")]
merged_orders = [
self.run_merge_bin("esp8266", perm_args)
for perm_args in itertools.permutations(args)
]
for m in merged_orders:
assert m == merged_orders[0]
def test_error_overlap(self, capsys):
args = [(0x1000, "one_mb.bin"), (0x20000, "one_kb.bin")]
for perm_args in itertools.permutations(args):
with pytest.raises(subprocess.CalledProcessError):
self.run_merge_bin("esp32", perm_args)
output = capsys.readouterr().out
assert "overlap" in output
def test_leading_padding(self):
merged = self.run_merge_bin("esp32c3", [(0x100000, "one_mb.bin")])
self.assertAllFF(merged[:0x100000])
assert read_image("one_mb.bin") == merged[0x100000:]
def test_update_bootloader_params(self):
merged = self.run_merge_bin(
"esp32",
[
(0x1000, "bootloader_esp32.bin"),
(0x10000, "ram_helloworld/helloworld-esp32.bin"),
],
["--flash_size", "2MB", "--flash_mode", "dout"],
)
self.assertAllFF(merged[:0x1000])
bootloader = read_image("bootloader_esp32.bin")
helloworld = read_image("ram_helloworld/helloworld-esp32.bin")
# test the bootloader is unchanged apart from the header
# (updating the header doesn't change CRC,
# and doesn't update the SHA although it will invalidate it!)
assert merged[0x1010 : 0x1000 + len(bootloader)] == bootloader[0x10:]
# check the individual bytes in the header are as expected
merged_hdr = merged[0x1000:0x1010]
bootloader_hdr = bootloader[:0x10]
assert bootloader_hdr[:2] == merged_hdr[:2]
assert byte(merged_hdr, 2) == 3 # flash mode dout
assert byte(merged_hdr, 3) & 0xF0 == 0x10 # flash size 2MB (ESP32)
# flash freq is unchanged
assert byte(bootloader_hdr, 3) & 0x0F == byte(merged_hdr, 3) & 0x0F
assert bootloader_hdr[4:] == merged_hdr[4:] # remaining field are unchanged
# check all the padding is as expected
self.assertAllFF(merged[0x1000 + len(bootloader) : 0x10000])
assert merged[0x10000 : 0x10000 + len(helloworld)], helloworld
def test_target_offset(self):
merged = self.run_merge_bin(
"esp32",
[
(0x1000, "bootloader_esp32.bin"),
(0x10000, "ram_helloworld/helloworld-esp32.bin"),
],
["--target-offset", "0x1000"],
)
bootloader = read_image("bootloader_esp32.bin")
helloworld = read_image("ram_helloworld/helloworld-esp32.bin")
assert bootloader == merged[: len(bootloader)]
assert helloworld == merged[0xF000 : 0xF000 + len(helloworld)]
self.assertAllFF(merged[0x1000 + len(bootloader) : 0xF000])
def test_fill_flash_size(self):
merged = self.run_merge_bin(
"esp32c3", [(0x0, "bootloader_esp32c3.bin")], ["--fill-flash-size", "4MB"]
)
bootloader = read_image("bootloader_esp32c3.bin")
assert len(merged) == 0x400000
assert bootloader == merged[: len(bootloader)]
self.assertAllFF(merged[len(bootloader) :])
def test_fill_flash_size_w_target_offset(self):
merged = self.run_merge_bin(
"esp32",
[
(0x1000, "bootloader_esp32.bin"),
(0x10000, "ram_helloworld/helloworld-esp32.bin"),
],
["--target-offset", "0x1000", "--fill-flash-size", "2MB"],
)
# full length is without target-offset arg
assert len(merged) == 0x200000 - 0x1000
bootloader = read_image("bootloader_esp32.bin")
helloworld = read_image("ram_helloworld/helloworld-esp32.bin")
assert bootloader == merged[: len(bootloader)]
assert helloworld == merged[0xF000 : 0xF000 + len(helloworld)]
self.assertAllFF(merged[0xF000 + len(helloworld) :])
| 6,839 | Python | .py | 158 | 33.240506 | 86 | 0.594013 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,580 | sitecustomize.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/sitecustomize.py | try:
import coverage
coverage.process_startup()
except ModuleNotFoundError:
print("Coverage.py is not installed, skipping code coverage measurement")
# This file exists to perform arbitrary site-specific customizations.
# This script is executed before every Python process to start coverage measurement.
| 319 | Python | .py | 7 | 42.571429 | 84 | 0.812903 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,581 | test_esptool.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_esptool.py | # Unit tests (really integration tests) for esptool.py using the pytest framework
# Uses a device connected to the serial port.
#
# RUNNING THIS WILL MESS UP THE DEVICE'S SPI FLASH CONTENTS
#
# How to use:
#
# Run with a physical connection to a chip:
# - `pytest test_esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 115200`
#
# where - --port - a serial port for esptool.py operation
# - --chip - ESP chip name
# - --baud - baud rate
# - --with-trace - trace all interactions (True or False)
import os
import os.path
import random
import re
import struct
import subprocess
import sys
import tempfile
import time
from socket import AF_INET, SOCK_STREAM, socket
from time import sleep
from unittest.mock import MagicMock
# Link command line options --port, --chip, --baud, --with-trace, and --preload-port
from conftest import (
arg_baud,
arg_chip,
arg_port,
arg_preload_port,
arg_trace,
need_to_install_package_err,
)
import pytest
try:
import esptool
import espefuse
except ImportError:
need_to_install_package_err()
import serial
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
# esptool.py skips strapping mode check in USB-CDC case if this is set
os.environ["ESPTOOL_TESTING"] = "1"
print("Running esptool.py tests...")
class ESPRFC2217Server(object):
"""Creates a virtual serial port accessible through rfc2217 port."""
def __init__(self, rfc2217_port=None):
self.port = rfc2217_port or self.get_free_port()
self.cmd = [
sys.executable,
os.path.join(TEST_DIR, "..", "esp_rfc2217_server.py"),
"-p",
str(self.port),
arg_port,
]
self.server_output_file = open(f"{TEST_DIR}/{str(arg_chip)}_server.out", "a")
self.server_output_file.write("************************************")
self.p = None
self.wait_for_server_starts(attempts_count=5)
@staticmethod
def get_free_port():
s = socket(AF_INET, SOCK_STREAM)
s.bind(("", 0))
port = s.getsockname()[1]
s.close()
return port
def wait_for_server_starts(self, attempts_count):
for attempt in range(attempts_count):
try:
self.p = subprocess.Popen(
self.cmd,
cwd=TEST_DIR,
stdout=self.server_output_file,
stderr=subprocess.STDOUT,
close_fds=True,
)
sleep(2)
s = socket(AF_INET, SOCK_STREAM)
result = s.connect_ex(("localhost", self.port))
s.close()
if result == 0:
print("Server started successfully.")
return
except Exception as e:
print(e)
print(
"Server start failed."
+ (" Retrying . . ." if attempt < attempts_count - 1 else "")
)
self.p.terminate()
raise Exception("Server not started successfully!")
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.server_output_file.close()
self.p.terminate()
# Re-run all tests at least once if failure happens in USB-JTAG/Serial
@pytest.mark.flaky(reruns=1, condition=arg_preload_port is not False)
class EsptoolTestCase:
def run_espsecure(self, args):
cmd = [sys.executable, "-m", "espsecure"] + args.split(" ")
print("\nExecuting {}...".format(" ".join(cmd)))
try:
output = subprocess.check_output(
[str(s) for s in cmd], cwd=TEST_DIR, stderr=subprocess.STDOUT
)
output = output.decode("utf-8")
print(output) # for more complete stdout logs on failure
return output
except subprocess.CalledProcessError as e:
print(e.output)
raise e
def run_esptool(self, args, baud=None, chip=None, port=None, preload=True):
"""
Run esptool with the specified arguments. --chip, --port and --baud
are filled in automatically from the command line.
(These can be overriden with their respective params.)
Additional args passed in args parameter as a string.
Preloads a dummy binary if --preload_port is specified.
This is needed in USB-JTAG/Serial mode to disable the
RTC watchdog, which causes the port to periodically disappear.
Returns output from esptool.py as a string if there is any.
Raises an exception if esptool.py fails.
"""
def run_esptool_process(cmd):
print("Executing {}...".format(" ".join(cmd)))
try:
output = subprocess.check_output(
[str(s) for s in cmd],
cwd=TEST_DIR,
stderr=subprocess.STDOUT,
)
return output.decode("utf-8")
except subprocess.CalledProcessError as e:
print(e.output.decode("utf-8"))
raise e
try:
# Used for flasher_stub/run_tests_with_stub.sh
esptool = [os.environ["ESPTOOL_PY"]]
except KeyError:
# Run the installed esptool module
esptool = ["-m", "esptool"]
trace_arg = ["--trace"] if arg_trace else []
base_cmd = [sys.executable] + esptool + trace_arg
if chip or arg_chip is not None and chip != "auto":
base_cmd += ["--chip", chip or arg_chip]
if port or arg_port is not None:
base_cmd += ["--port", port or arg_port]
if baud or arg_baud is not None:
base_cmd += ["--baud", str(baud or arg_baud)]
usb_jtag_serial_reset = ["--before", "usb_reset"] if arg_preload_port else []
full_cmd = base_cmd + usb_jtag_serial_reset + args.split(" ")
# Preload a dummy binary to disable the RTC watchdog, needed in USB-JTAG/Serial
if (
preload
and arg_preload_port
and arg_chip
in ["esp32c3", "esp32s3", "esp32c6", "esp32h2"] # With USB-JTAG/Serial
):
port_index = base_cmd.index("--port") + 1
base_cmd[port_index] = arg_preload_port # Set the port to the preload one
preload_cmd = base_cmd + [
"--no-stub",
"load_ram",
f"{TEST_DIR}/images/ram_helloworld/helloworld-{arg_chip}.bin",
]
print("\nPreloading dummy binary to disable RTC watchdog...")
run_esptool_process(preload_cmd)
print("Dummy binary preloaded successfully.")
time.sleep(0.3) # Wait for the app to run and port to appear
# Run the command
print(f'\nRunning the "{args}" command...')
output = run_esptool_process(full_cmd)
print(output) # for more complete stdout logs on failure
return output
def run_esptool_error(self, args, baud=None):
"""
Run esptool.py similar to run_esptool, but expect an error.
Verifies the error is an expected error not an unhandled exception,
and returns the output from esptool.py as a string.
"""
with pytest.raises(subprocess.CalledProcessError) as fail:
self.run_esptool(args, baud)
failure = fail.value
assert failure.returncode == 2 # esptool.FatalError return code
return failure.output.decode("utf-8")
@classmethod
def setup_class(self):
print()
print(50 * "*")
# Save the current working directory to be resotred later
self.stored_dir = os.getcwd()
os.chdir(TEST_DIR)
@classmethod
def teardown_class(self):
# Restore the stored working directory
os.chdir(self.stored_dir)
def readback(self, offset, length):
"""Read contents of flash back, return to caller."""
dump_file = tempfile.NamedTemporaryFile(delete=False) # a file we can read into
try:
self.run_esptool(
f"--before default_reset read_flash {offset} {length} {dump_file.name}"
)
with open(dump_file.name, "rb") as f:
rb = f.read()
assert length == len(
rb
), f"read_flash length {length} offset {offset:#x} yielded {len(rb)} bytes!"
return rb
finally:
dump_file.close()
os.unlink(dump_file.name)
def verify_readback(self, offset, length, compare_to, is_bootloader=False):
rb = self.readback(offset, length)
with open(compare_to, "rb") as f:
ct = f.read()
if len(rb) != len(ct):
print(
f"WARNING: Expected length {len(ct)} doesn't match comparison {len(rb)}"
)
print(f"Readback {len(rb)} bytes")
if is_bootloader:
# writing a bootloader image to bootloader offset can set flash size/etc,
# so don't compare the 8 byte header
assert ct[0] == rb[0], "First bytes should be identical"
rb = rb[8:]
ct = ct[8:]
for rb_b, ct_b, offs in zip(rb, ct, range(len(rb))):
assert (
rb_b == ct_b
), f"First difference at offset {offs:#x} Expected {ct_b} got {rb_b}"
@pytest.mark.skipif(arg_chip != "esp32", reason="ESP32 only")
class TestFlashEncryption(EsptoolTestCase):
def valid_key_present(self):
try:
esp = esptool.ESP32ROM(arg_port)
esp.connect()
efuses, _ = espefuse.get_efuses(esp=esp)
blk1_rd_en = efuses["BLOCK1"].is_readable()
return not blk1_rd_en
finally:
esp._port.close()
def test_blank_efuse_encrypt_write_abort(self):
"""
since flash crypt config is not set correctly, this test should abort write
"""
if self.valid_key_present() is True:
pytest.skip("Valid encryption key already programmed, aborting the test")
self.run_esptool(
"write_flash 0x1000 images/bootloader_esp32.bin "
"0x8000 images/partitions_singleapp.bin "
"0x10000 images/ram_helloworld/helloworld-esp32.bin"
)
output = self.run_esptool_error(
"write_flash --encrypt 0x10000 images/ram_helloworld/helloworld-esp32.bin"
)
assert "Flash encryption key is not programmed".lower() in output.lower()
def test_blank_efuse_encrypt_write_continue1(self):
"""
since ignore option is specified, write should happen even though flash crypt
config is 0
later encrypted flash contents should be read back & compared with
precomputed ciphertext
pass test
"""
if self.valid_key_present() is True:
pytest.skip("Valid encryption key already programmed, aborting the test")
self.run_esptool(
"write_flash --encrypt --ignore-flash-encryption-efuse-setting "
"0x10000 images/ram_helloworld/helloworld-esp32.bin"
)
self.run_esptool("read_flash 0x10000 192 images/read_encrypted_flash.bin")
self.run_espsecure(
"encrypt_flash_data --address 0x10000 --keyfile images/aes_key.bin "
"--flash_crypt_conf 0 --output images/local_enc.bin "
"images/ram_helloworld/helloworld-esp32.bin"
)
try:
with open("images/read_encrypted_flash.bin", "rb") as file1:
read_file1 = file1.read()
with open("images/local_enc.bin", "rb") as file2:
read_file2 = file2.read()
for rf1, rf2, i in zip(read_file1, read_file2, range(len(read_file2))):
assert (
rf1 == rf2
), f"Encrypted write failed: file mismatch at byte position {i}"
print("Encrypted write success")
finally:
os.remove("images/read_encrypted_flash.bin")
os.remove("images/local_enc.bin")
def test_blank_efuse_encrypt_write_continue2(self):
"""
since ignore option is specified, write should happen even though flash crypt
config is 0
later encrypted flash contents should be read back & compared with
precomputed ciphertext
fail test
"""
if self.valid_key_present() is True:
pytest.skip("Valid encryption key already programmed, aborting the test")
self.run_esptool(
"write_flash --encrypt --ignore-flash-encryption-efuse-setting "
"0x10000 images/ram_helloworld/helloworld-esp32_edit.bin"
)
self.run_esptool("read_flash 0x10000 192 images/read_encrypted_flash.bin")
self.run_espsecure(
"encrypt_flash_data --address 0x10000 --keyfile images/aes_key.bin "
"--flash_crypt_conf 0 --output images/local_enc.bin "
"images/ram_helloworld/helloworld-esp32.bin"
)
try:
with open("images/read_encrypted_flash.bin", "rb") as file1:
read_file1 = file1.read()
with open("images/local_enc.bin", "rb") as file2:
read_file2 = file2.read()
mismatch = any(rf1 != rf2 for rf1, rf2 in zip(read_file1, read_file2))
assert mismatch, "Files should mismatch"
finally:
os.remove("images/read_encrypted_flash.bin")
os.remove("images/local_enc.bin")
class TestFlashing(EsptoolTestCase):
@pytest.mark.quick_test
def test_short_flash(self):
self.run_esptool("write_flash 0x0 images/one_kb.bin")
self.verify_readback(0, 1024, "images/one_kb.bin")
@pytest.mark.quick_test
def test_highspeed_flash(self):
self.run_esptool("write_flash 0x0 images/fifty_kb.bin", baud=921600)
self.verify_readback(0, 50 * 1024, "images/fifty_kb.bin")
def test_adjacent_flash(self):
self.run_esptool("write_flash 0x0 images/sector.bin 0x1000 images/fifty_kb.bin")
self.verify_readback(0, 4096, "images/sector.bin")
self.verify_readback(4096, 50 * 1024, "images/fifty_kb.bin")
def test_adjacent_independent_flash(self):
self.run_esptool("write_flash 0x0 images/sector.bin")
self.verify_readback(0, 4096, "images/sector.bin")
self.run_esptool("write_flash 0x1000 images/fifty_kb.bin")
self.verify_readback(4096, 50 * 1024, "images/fifty_kb.bin")
# writing flash the second time shouldn't have corrupted the first time
self.verify_readback(0, 4096, "images/sector.bin")
@pytest.mark.skipif(
int(os.getenv("ESPTOOL_TEST_FLASH_SIZE", "0")) < 32, reason="needs 32MB flash"
)
def test_last_bytes_of_32M_flash(self):
flash_size = 32 * 1024 * 1024
image_size = 1024
offset = flash_size - image_size
self.run_esptool("write_flash {} images/one_kb.bin".format(hex(offset)))
# Some of the functons cannot handle 32-bit addresses - i.e. addresses accessing
# the higher 16MB will manipulate with the lower 16MB flash area.
offset2 = offset & 0xFFFFFF
self.run_esptool("write_flash {} images/one_kb_all_ef.bin".format(hex(offset2)))
self.verify_readback(offset, image_size, "images/one_kb.bin")
@pytest.mark.skipif(
int(os.getenv("ESPTOOL_TEST_FLASH_SIZE", "0")) < 32, reason="needs 32MB flash"
)
def test_write_larger_area_to_32M_flash(self):
offset = 18 * 1024 * 1024
self.run_esptool("write_flash {} images/one_mb.bin".format(hex(offset)))
# Some of the functons cannot handle 32-bit addresses - i.e. addresses accessing
# the higher 16MB will manipulate with the lower 16MB flash area.
offset2 = offset & 0xFFFFFF
self.run_esptool("write_flash {} images/one_kb_all_ef.bin".format(hex(offset2)))
self.verify_readback(offset, 1 * 1024 * 1024, "images/one_mb.bin")
def test_correct_offset(self):
"""Verify writing at an offset actually writes to that offset."""
self.run_esptool("write_flash 0x2000 images/sector.bin")
time.sleep(0.1)
three_sectors = self.readback(0, 0x3000)
last_sector = three_sectors[0x2000:]
with open("images/sector.bin", "rb") as f:
ct = f.read()
assert last_sector == ct
@pytest.mark.quick_test
def test_no_compression_flash(self):
self.run_esptool(
"write_flash -u 0x0 images/sector.bin 0x1000 images/fifty_kb.bin"
)
self.verify_readback(0, 4096, "images/sector.bin")
self.verify_readback(4096, 50 * 1024, "images/fifty_kb.bin")
@pytest.mark.quick_test
@pytest.mark.skipif(arg_chip == "esp8266", reason="Added in ESP32")
def test_compressed_nostub_flash(self):
self.run_esptool(
"--no-stub write_flash -z 0x0 images/sector.bin 0x1000 images/fifty_kb.bin"
)
self.verify_readback(0, 4096, "images/sector.bin")
self.verify_readback(4096, 50 * 1024, "images/fifty_kb.bin")
def _test_partition_table_then_bootloader(self, args):
self.run_esptool(args + " 0x4000 images/partitions_singleapp.bin")
self.verify_readback(0x4000, 96, "images/partitions_singleapp.bin")
self.run_esptool(args + " 0x1000 images/bootloader_esp32.bin")
self.verify_readback(0x1000, 7888, "images/bootloader_esp32.bin", True)
self.verify_readback(0x4000, 96, "images/partitions_singleapp.bin")
def test_partition_table_then_bootloader(self):
self._test_partition_table_then_bootloader("write_flash --force")
def test_partition_table_then_bootloader_no_compression(self):
self._test_partition_table_then_bootloader("write_flash --force -u")
def test_partition_table_then_bootloader_nostub(self):
self._test_partition_table_then_bootloader("--no-stub write_flash --force")
# note: there is no "partition table then bootloader" test that
# uses --no-stub and -z, as the ESP32 ROM over-erases and can't
# flash this set of files in this order. we do
# test_compressed_nostub_flash() instead.
def test_length_not_aligned_4bytes(self):
self.run_esptool("write_flash 0x0 images/not_4_byte_aligned.bin")
def test_length_not_aligned_4bytes_no_compression(self):
self.run_esptool("write_flash -u 0x0 images/not_4_byte_aligned.bin")
@pytest.mark.quick_test
@pytest.mark.host_test
def test_write_overlap(self):
output = self.run_esptool_error(
"write_flash 0x0 images/bootloader_esp32.bin 0x1000 images/one_kb.bin"
)
assert "Detected overlap at address: 0x1000 " in output
@pytest.mark.quick_test
@pytest.mark.host_test
def test_repeated_address(self):
output = self.run_esptool_error(
"write_flash 0x0 images/one_kb.bin 0x0 images/one_kb.bin"
)
assert "Detected overlap at address: 0x0 " in output
@pytest.mark.quick_test
@pytest.mark.host_test
def test_write_sector_overlap(self):
# These two 1KB files don't overlap,
# but they do both touch sector at 0x1000 so should fail
output = self.run_esptool_error(
"write_flash 0xd00 images/one_kb.bin 0x1d00 images/one_kb.bin"
)
assert "Detected overlap at address: 0x1d00" in output
def test_write_no_overlap(self):
output = self.run_esptool(
"write_flash 0x0 images/one_kb.bin 0x2000 images/one_kb.bin"
)
assert "Detected overlap at address" not in output
def test_compressible_file(self):
try:
input_file = tempfile.NamedTemporaryFile(delete=False)
file_size = 1024 * 1024
input_file.write(b"\x00" * file_size)
input_file.close()
self.run_esptool(f"write_flash 0x10000 {input_file.name}")
finally:
os.unlink(input_file.name)
def test_compressible_non_trivial_file(self):
try:
input_file = tempfile.NamedTemporaryFile(delete=False)
file_size = 1000 * 1000
same_bytes = 8000
for _ in range(file_size // same_bytes):
input_file.write(
struct.pack("B", random.randrange(0, 1 << 8)) * same_bytes
)
input_file.close()
self.run_esptool(f"write_flash 0x10000 {input_file.name}")
finally:
os.unlink(input_file.name)
@pytest.mark.quick_test
def test_zero_length(self):
# Zero length files are skipped with a warning
output = self.run_esptool(
"write_flash 0x10000 images/one_kb.bin 0x11000 images/zerolength.bin"
)
self.verify_readback(0x10000, 1024, "images/one_kb.bin")
assert "zerolength.bin is empty" in output
@pytest.mark.quick_test
def test_single_byte(self):
self.run_esptool("write_flash 0x0 images/onebyte.bin")
self.verify_readback(0x0, 1, "images/onebyte.bin")
def test_erase_range_messages(self):
output = self.run_esptool(
"write_flash 0x1000 images/sector.bin 0x0FC00 images/one_kb.bin"
)
assert "Flash will be erased from 0x00001000 to 0x00001fff..." in output
assert (
"WARNING: Flash address 0x0000fc00 is not aligned to a 0x1000 "
"byte flash sector. 0xc00 bytes before this address will be erased."
in output
)
assert "Flash will be erased from 0x0000f000 to 0x0000ffff..." in output
@pytest.mark.skipif(
arg_chip == "esp8266", reason="chip_id field exist in ESP32 and later images"
)
@pytest.mark.skipif(
arg_chip == "esp32s3", reason="This is a valid ESP32-S3 image, would pass"
)
def test_write_image_for_another_target(self):
output = self.run_esptool_error(
"write_flash 0x0 images/esp32s3_header.bin 0x1000 images/one_kb.bin"
)
assert "Unexpected chip id in image." in output
assert "value was 9. Is this image for a different chip model?" in output
assert "images/esp32s3_header.bin is not an " in output
assert "image. Use --force to flash anyway." in output
@pytest.mark.skipif(
arg_chip == "esp8266", reason="chip_id field exist in ESP32 and later images"
)
@pytest.mark.skipif(
arg_chip != "esp32s3", reason="This check happens only on a valid image"
)
def test_write_image_for_another_revision(self):
output = self.run_esptool_error(
"write_flash 0x0 images/one_kb.bin 0x1000 images/esp32s3_header.bin"
)
assert "images/esp32s3_header.bin requires chip revision 10" in output
assert "or higher (this chip is revision" in output
assert "Use --force to flash anyway." in output
@pytest.mark.skipif(
arg_chip != "esp32c3", reason="This check happens only on a valid image"
)
def test_flash_with_min_max_rev(self):
"""Use min/max_rev_full field to specify chip revision"""
output = self.run_esptool_error(
"write_flash 0x0 images/one_kb.bin 0x1000 images/esp32c3_header_min_rev.bin"
)
assert (
"images/esp32c3_header_min_rev.bin "
"requires chip revision in range [v0.10 - max rev not set]" in output
)
assert "Use --force to flash anyway." in output
@pytest.mark.quick_test
def test_erase_before_write(self):
output = self.run_esptool("write_flash --erase-all 0x0 images/one_kb.bin")
assert "Chip erase completed successfully" in output
assert "Hash of data verified" in output
@pytest.mark.skipif(
arg_chip in ["esp8266", "esp32"],
reason="get_security_info command is supported on ESP32S2 and later",
)
class TestSecurityInfo(EsptoolTestCase):
def test_show_security_info(self):
res = self.run_esptool("get_security_info")
assert "Flags" in res
assert "Crypt Count" in res
assert "Key Purposes" in res
if arg_chip != "esp32s2":
esp = esptool.get_default_connected_device(
[arg_port], arg_port, 10, 115200, arg_chip
)
assert f"Chip ID: {esp.IMAGE_CHIP_ID}" in res
assert "API Version" in res
assert "Secure Boot" in res
assert "Flash Encryption" in res
class TestFlashSizes(EsptoolTestCase):
def test_high_offset(self):
self.run_esptool("write_flash -fs 4MB 0x300000 images/one_kb.bin")
self.verify_readback(0x300000, 1024, "images/one_kb.bin")
def test_high_offset_no_compression(self):
self.run_esptool("write_flash -u -fs 4MB 0x300000 images/one_kb.bin")
self.verify_readback(0x300000, 1024, "images/one_kb.bin")
def test_large_image(self):
self.run_esptool("write_flash -fs 4MB 0x280000 images/one_mb.bin")
self.verify_readback(0x280000, 0x100000, "images/one_mb.bin")
def test_large_no_compression(self):
self.run_esptool("write_flash -u -fs 4MB 0x280000 images/one_mb.bin")
self.verify_readback(0x280000, 0x100000, "images/one_mb.bin")
@pytest.mark.quick_test
@pytest.mark.host_test
def test_invalid_size_arg(self):
self.run_esptool_error("write_flash -fs 10MB 0x6000 images/one_kb.bin")
def test_write_past_end_fails(self):
output = self.run_esptool_error(
"write_flash -fs 1MB 0x280000 images/one_kb.bin"
)
assert "File images/one_kb.bin" in output
assert "will not fit" in output
def test_write_no_compression_past_end_fails(self):
output = self.run_esptool_error(
"write_flash -u -fs 1MB 0x280000 images/one_kb.bin"
)
assert "File images/one_kb.bin" in output
assert "will not fit" in output
@pytest.mark.skipif(
arg_chip not in ["esp8266", "esp32", "esp32c3"],
reason="Don't run on every chip, so other bootloader images are not needed",
)
def test_flash_size_keep(self):
offset = 0x1000 if arg_chip in ["esp32", "esp32s2"] else 0x0
# this image is configured for 2MB (512KB on ESP8266) flash by default.
# assume this is not the flash size in use
image = f"images/bootloader_{arg_chip}.bin"
with open(image, "rb") as f:
f.seek(0, 2)
image_len = f.tell()
self.run_esptool(f"write_flash -fs keep {offset} {image}")
# header should be the same as in the .bin file
self.verify_readback(offset, image_len, image)
class TestFlashDetection(EsptoolTestCase):
@pytest.mark.quick_test
def test_flash_id(self):
"""Test manufacturer and device response of flash detection."""
res = self.run_esptool("flash_id")
assert "Manufacturer:" in res
assert "Device:" in res
@pytest.mark.quick_test
def test_flash_id_expand_args(self):
"""
Test manufacturer and device response of flash detection with expandable arg
"""
try:
arg_file = tempfile.NamedTemporaryFile(delete=False)
arg_file.write(b"flash_id\n")
arg_file.close()
res = self.run_esptool(f"@{arg_file.name}")
assert "Manufacturer:" in res
assert "Device:" in res
finally:
os.unlink(arg_file.name)
@pytest.mark.quick_test
def test_flash_id_trace(self):
"""Test trace functionality on flash detection, running without stub"""
res = self.run_esptool("--trace flash_id")
# read register command
assert re.search(r"TRACE \+\d.\d{3} command op=0x0a .*", res) is not None
# write register command
assert re.search(r"TRACE \+\d.\d{3} command op=0x09 .*", res) is not None
assert re.search(r"TRACE \+\d.\d{3} Read \d* bytes: .*", res) is not None
assert re.search(r"TRACE \+\d.\d{3} Write \d* bytes: .*", res) is not None
assert re.search(r"TRACE \+\d.\d{3} Received full packet: .*", res) is not None
# flasher stub handshake
assert (
re.search(r"TRACE \+\d.\d{3} Received full packet: 4f484149", res)
is not None
)
assert "Manufacturer:" in res
assert "Device:" in res
@pytest.mark.skipif(
os.name == "nt", reason="Temporarily disabled on windows"
) # TODO: ESPTOOL-673
class TestStubReuse(EsptoolTestCase):
def test_stub_reuse_with_synchronization(self):
"""Keep the flasher stub running and reuse it the next time."""
res = self.run_esptool(
"--after no_reset_stub flash_id"
) # flasher stub keeps running after this
assert "Manufacturer:" in res
res = self.run_esptool(
"--before no_reset flash_id",
preload=False,
) # do sync before (without reset it talks to the flasher stub)
assert "Manufacturer:" in res
@pytest.mark.skipif(arg_chip != "esp8266", reason="ESP8266 only")
def test_stub_reuse_without_synchronization(self):
"""
Keep the flasher stub running and reuse it the next time
without synchronization.
Synchronization is necessary for chips where the ROM bootloader has different
status length in comparison to the flasher stub.
Therefore, this is ESP8266 only test.
"""
res = self.run_esptool("--after no_reset_stub flash_id")
assert "Manufacturer:" in res
res = self.run_esptool("--before no_reset_no_sync flash_id")
assert "Manufacturer:" in res
class TestErase(EsptoolTestCase):
@pytest.mark.quick_test
def test_chip_erase(self):
self.run_esptool("write_flash 0x10000 images/one_kb.bin")
self.verify_readback(0x10000, 0x400, "images/one_kb.bin")
self.run_esptool("erase_flash")
empty = self.readback(0x10000, 0x400)
assert empty == b"\xFF" * 0x400
def test_region_erase(self):
self.run_esptool("write_flash 0x10000 images/one_kb.bin")
self.run_esptool("write_flash 0x11000 images/sector.bin")
self.verify_readback(0x10000, 0x400, "images/one_kb.bin")
self.verify_readback(0x11000, 0x1000, "images/sector.bin")
# erase only the flash sector containing one_kb.bin
self.run_esptool("erase_region 0x10000 0x1000")
self.verify_readback(0x11000, 0x1000, "images/sector.bin")
empty = self.readback(0x10000, 0x1000)
assert empty == b"\xFF" * 0x1000
def test_region_erase_all(self):
res = self.run_esptool("erase_region 0x0 ALL")
assert re.search(r"Detected flash size: \d+[KM]B", res) is not None
def test_large_region_erase(self):
# verifies that erasing a large region doesn't time out
self.run_esptool("erase_region 0x0 0x100000")
class TestSectorBoundaries(EsptoolTestCase):
def test_end_sector(self):
self.run_esptool("write_flash 0x10000 images/sector.bin")
self.run_esptool("write_flash 0x0FC00 images/one_kb.bin")
self.verify_readback(0x0FC00, 0x400, "images/one_kb.bin")
self.verify_readback(0x10000, 0x1000, "images/sector.bin")
def test_end_sector_uncompressed(self):
self.run_esptool("write_flash -u 0x10000 images/sector.bin")
self.run_esptool("write_flash -u 0x0FC00 images/one_kb.bin")
self.verify_readback(0x0FC00, 0x400, "images/one_kb.bin")
self.verify_readback(0x10000, 0x1000, "images/sector.bin")
def test_overlap(self):
self.run_esptool("write_flash 0x20800 images/sector.bin")
self.verify_readback(0x20800, 0x1000, "images/sector.bin")
class TestVerifyCommand(EsptoolTestCase):
@pytest.mark.quick_test
def test_verify_success(self):
self.run_esptool("write_flash 0x5000 images/one_kb.bin")
self.run_esptool("verify_flash 0x5000 images/one_kb.bin")
def test_verify_failure(self):
self.run_esptool("write_flash 0x6000 images/sector.bin")
output = self.run_esptool_error(
"verify_flash --diff=yes 0x6000 images/one_kb.bin"
)
assert "verify FAILED" in output
assert "first @ 0x00006000" in output
def test_verify_unaligned_length(self):
self.run_esptool("write_flash 0x0 images/not_4_byte_aligned.bin")
self.run_esptool("verify_flash 0x0 images/not_4_byte_aligned.bin")
class TestReadIdentityValues(EsptoolTestCase):
@pytest.mark.quick_test
def test_read_mac(self):
output = self.run_esptool("read_mac")
mac = re.search(r"[0-9a-f:]{17}", output)
assert mac is not None
mac = mac.group(0)
assert mac != "00:00:00:00:00:00"
assert mac != "ff:ff:ff:ff:ff:ff"
@pytest.mark.skipif(arg_chip != "esp8266", reason="ESP8266 only")
def test_read_chip_id(self):
output = self.run_esptool("chip_id")
idstr = re.search("Chip ID: 0x([0-9a-f]+)", output)
assert idstr is not None
idstr = idstr.group(1)
assert idstr != "0" * 8
assert idstr != "f" * 8
class TestMemoryOperations(EsptoolTestCase):
@pytest.mark.quick_test
def test_memory_dump(self):
output = self.run_esptool("dump_mem 0x50000000 128 memout.bin")
assert "Read 128 bytes" in output
os.remove("memout.bin")
def test_memory_write(self):
output = self.run_esptool("write_mem 0x400C0000 0xabad1dea 0x0000ffff")
assert "Wrote abad1dea" in output
assert "mask 0000ffff" in output
assert "to 400c0000" in output
def test_memory_read(self):
output = self.run_esptool("read_mem 0x400C0000")
assert "0x400c0000 =" in output
class TestKeepImageSettings(EsptoolTestCase):
"""Tests for the -fm keep, -ff keep options for write_flash"""
@classmethod
def setup_class(self):
super(TestKeepImageSettings, self).setup_class()
self.BL_IMAGE = f"images/bootloader_{arg_chip}.bin"
self.flash_offset = (
0x1000 if arg_chip in ("esp32", "esp32s2") else 0
) # bootloader offset
with open(self.BL_IMAGE, "rb") as f:
self.header = f.read(8)
@pytest.mark.skipif(
arg_chip not in ["esp8266", "esp32", "esp32c3"],
reason="Don't run on every chip, so other bootloader images are not needed",
)
def test_keep_does_not_change_settings(self):
# defaults should all be keep
self.run_esptool(f"write_flash -fs keep {self.flash_offset:#x} {self.BL_IMAGE}")
self.verify_readback(self.flash_offset, 8, self.BL_IMAGE, False)
# can also explicitly set all options
self.run_esptool(
f"write_flash -fm keep -ff keep -fs keep "
f"{self.flash_offset:#x} {self.BL_IMAGE}"
)
self.verify_readback(self.flash_offset, 8, self.BL_IMAGE, False)
# verify_flash should also use 'keep'
self.run_esptool(
f"verify_flash -fs keep {self.flash_offset:#x} {self.BL_IMAGE}"
)
@pytest.mark.skipif(
arg_chip not in ["esp8266", "esp32", "esp32c3"],
reason="Don't run for every chip, so other bootloader images are not needed",
)
@pytest.mark.quick_test
def test_detect_size_changes_size(self):
self.run_esptool(
f"write_flash -fs detect {self.flash_offset:#x} {self.BL_IMAGE}"
)
readback = self.readback(self.flash_offset, 8)
assert self.header[:3] == readback[:3] # first 3 bytes unchanged
if arg_chip in ["esp8266", "esp32"]:
assert self.header[3] != readback[3] # size_freq byte changed
else:
# Not changed because protected by SHA256 digest
assert self.header[3] == readback[3] # size_freq byte unchanged
assert self.header[4:] == readback[4:] # rest unchanged
@pytest.mark.skipif(
arg_chip not in ["esp8266", "esp32"],
reason="Bootloader header needs to be modifiable - without sha256",
)
def test_explicit_set_size_freq_mode(self):
self.run_esptool(
f"write_flash -fs 2MB -fm dout -ff 80m "
f"{self.flash_offset:#x} {self.BL_IMAGE}"
)
readback = self.readback(self.flash_offset, 8)
assert self.header[0] == readback[0]
assert self.header[1] == readback[1]
assert (0x3F if arg_chip == "esp8266" else 0x1F) == readback[3] # size_freq
assert 3 != self.header[2] # original image not dout mode
assert 3 == readback[2] # value in flash is dout mode
assert self.header[3] != readback[3] # size/freq values have changed
assert self.header[4:] == readback[4:] # entrypoint address hasn't changed
# verify_flash should pass if we match params, fail otherwise
self.run_esptool(
f"verify_flash -fs 2MB -fm dout -ff 80m "
f"{self.flash_offset:#x} {self.BL_IMAGE}"
)
self.run_esptool_error(f"verify_flash {self.flash_offset:#x} {self.BL_IMAGE}")
@pytest.mark.skipif(
arg_chip in ["esp32s2", "esp32s3"],
reason="Not supported on targets with USB-CDC.",
)
class TestLoadRAM(EsptoolTestCase):
# flashing an application not supporting USB-CDC will make
# /dev/ttyACM0 disappear and USB-CDC tests will not work anymore
@pytest.mark.quick_test
def test_load_ram(self):
"""Verify load_ram command
The "hello world" binary programs for each chip print
"Hello world!\n" to the serial port.
"""
self.run_esptool(f"load_ram images/ram_helloworld/helloworld-{arg_chip}.bin")
try:
p = serial.serial_for_url(arg_port, arg_baud)
p.timeout = 5
output = p.read(100)
print(f"Output: {output}")
assert (
b"Hello world!" in output # xtensa
or b'\xce?\x13\x05\x04\xd0\x97A\x11"\xc4\x06\xc67\x04' in output # C3
)
finally:
p.close()
class TestDeepSleepFlash(EsptoolTestCase):
@pytest.mark.skipif(arg_chip != "esp8266", reason="ESP8266 only")
def test_deep_sleep_flash(self):
"""Regression test for https://github.com/espressif/esptool/issues/351
ESP8266 deep sleep can disable SPI flash chip,
stub loader (or ROM loader) needs to re-enable it.
NOTE: If this test fails, the ESP8266 may need a hard power cycle
(probably with GPIO0 held LOW) to recover.
"""
# not even necessary to wake successfully from sleep,
# going into deep sleep is enough
# (so GPIO16, etc, config is not important for this test)
self.run_esptool("write_flash 0x0 images/esp8266_deepsleep.bin", baud=230400)
time.sleep(0.25) # give ESP8266 time to enter deep sleep
self.run_esptool("write_flash 0x0 images/fifty_kb.bin", baud=230400)
self.verify_readback(0, 50 * 1024, "images/fifty_kb.bin")
class TestBootloaderHeaderRewriteCases(EsptoolTestCase):
@pytest.mark.skipif(
arg_chip not in ["esp8266", "esp32", "esp32c3"],
reason="Don't run on every chip, so other bootloader images are not needed",
)
@pytest.mark.quick_test
def test_flash_header_rewrite(self):
bl_offset = 0x1000 if arg_chip in ("esp32", "esp32s2") else 0
bl_image = f"images/bootloader_{arg_chip}.bin"
output = self.run_esptool(
f"write_flash -fm dout -ff 20m {bl_offset:#x} {bl_image}"
)
if arg_chip in ["esp8266", "esp32"]:
# There is no SHA256 digest so the header can be changed - ESP8266 doesn't
# support this; The test image for ESP32 just doesn't have it.
"Flash params set to" in output
else:
assert "Flash params set to" not in output
"not changing the flash mode setting" in output
"not changing the flash frequency setting" in output
def test_flash_header_no_magic_no_rewrite(self):
# first image doesn't start with magic byte, second image does
# but neither are valid bootloader binary images for either chip
bl_offset = 0x1000 if arg_chip in ("esp32", "esp32s2") else 0
for image in ["images/one_kb.bin", "images/one_kb_all_ef.bin"]:
output = self.run_esptool(
f"write_flash -fm dout -ff 20m {bl_offset:#x} {image}"
)
"not changing any flash settings" in output
self.verify_readback(bl_offset, 1024, image)
class TestAutoDetect(EsptoolTestCase):
def _check_output(self, output):
expected_chip_name = esptool.util.expand_chip_name(arg_chip)
if arg_chip not in ["esp8266", "esp32", "esp32s2"]:
assert "Unsupported detection protocol" not in output
assert f"Detecting chip type... {expected_chip_name}" in output
assert f"Chip is {expected_chip_name}" in output
@pytest.mark.quick_test
def test_auto_detect(self):
output = self.run_esptool("chip_id", chip="auto")
self._check_output(output)
@pytest.mark.flaky(reruns=5)
@pytest.mark.skipif(arg_preload_port is not False, reason="USB-to-UART bridge only")
@pytest.mark.skipif(os.name == "nt", reason="Linux/MacOS only")
class TestVirtualPort(TestAutoDetect):
def test_auto_detect_virtual_port(self):
with ESPRFC2217Server() as server:
output = self.run_esptool(
"chip_id",
chip="auto",
port=f"rfc2217://localhost:{str(server.port)}?ign_set_control",
)
self._check_output(output)
def test_highspeed_flash_virtual_port(self):
with ESPRFC2217Server() as server:
rfc2217_port = f"rfc2217://localhost:{str(server.port)}?ign_set_control"
self.run_esptool(
"write_flash 0x0 images/fifty_kb.bin",
baud=921600,
port=rfc2217_port,
)
self.verify_readback(0, 50 * 1024, "images/fifty_kb.bin")
@pytest.mark.quick_test
class TestReadWriteMemory(EsptoolTestCase):
def _test_read_write(self, esp):
# find the start of one of these named memory regions
test_addr = None
for test_region in [
"RTC_DRAM",
"RTC_DATA",
"DRAM",
]: # find a probably-unused memory type
region = esp.get_memory_region(test_region)
if region:
# Write at the end of DRAM on ESP32-C2 to avoid overwriting the stub
test_addr = region[1] - 8 if arg_chip == "esp32c2" else region[0]
break
print(f"Using test address {test_addr:#x}")
val = esp.read_reg(test_addr) # verify we can read this word at all
try:
esp.write_reg(test_addr, 0x1234567)
assert esp.read_reg(test_addr) == 0x1234567
esp.write_reg(test_addr, 0, delay_us=100)
assert esp.read_reg(test_addr) == 0
esp.write_reg(test_addr, 0x555, delay_after_us=100)
assert esp.read_reg(test_addr) == 0x555
finally:
esp.write_reg(test_addr, val) # write the original value, non-destructive
esp._port.close()
def test_read_write_memory_rom(self):
try:
esp = esptool.get_default_connected_device(
[arg_port], arg_port, 10, 115200, arg_chip
)
self._test_read_write(esp)
finally:
esp._port.close()
def test_read_write_memory_stub(self):
try:
esp = esptool.get_default_connected_device(
[arg_port], arg_port, 10, 115200, arg_chip
)
esp = esp.run_stub()
self._test_read_write(esp)
finally:
esp._port.close()
@pytest.mark.skipif(
arg_chip != "esp32", reason="Could be unsupported by different flash"
)
def test_read_write_flash_status(self):
"""Read flash status and write back the same status"""
res = self.run_esptool("read_flash_status")
match = re.search(r"Status value: (0x[\d|a-f]*)", res)
assert match is not None
res = self.run_esptool(f"write_flash_status {match.group(1)}")
assert f"Initial flash status: {match.group(1)}" in res
assert f"Setting flash status: {match.group(1)}" in res
assert f"After flash status: {match.group(1)}" in res
def test_read_chip_description(self):
try:
esp = esptool.get_default_connected_device(
[arg_port], arg_port, 10, 115200, arg_chip
)
chip = esp.get_chip_description()
assert "unknown" not in chip.lower()
finally:
esp._port.close()
def test_read_get_chip_features(self):
try:
esp = esptool.get_default_connected_device(
[arg_port], arg_port, 10, 115200, arg_chip
)
if hasattr(esp, "get_flash_cap") and esp.get_flash_cap() == 0:
esp.get_flash_cap = MagicMock(return_value=1)
if hasattr(esp, "get_psram_cap") and esp.get_psram_cap() == 0:
esp.get_psram_cap = MagicMock(return_value=1)
features = ", ".join(esp.get_chip_features())
assert "Unknown Embedded Flash" not in features
assert "Unknown Embedded PSRAM" not in features
finally:
esp._port.close()
@pytest.mark.skipif(
arg_chip != "esp8266", reason="Make image option is supported only on ESP8266"
)
class TestMakeImage(EsptoolTestCase):
def verify_image(self, offset, length, image, compare_to):
with open(image, "rb") as f:
f.seek(offset)
rb = f.read(length)
with open(compare_to, "rb") as f:
ct = f.read()
if len(rb) != len(ct):
print(
f"WARNING: Expected length {len(ct)} doesn't match comparison {len(rb)}"
)
print(f"Readback {len(rb)} bytes")
for rb_b, ct_b, offs in zip(rb, ct, range(len(rb))):
assert (
rb_b == ct_b
), f"First difference at offset {offs:#x} Expected {ct_b} got {rb_b}"
def test_make_image(self):
output = self.run_esptool(
"make_image test"
" -a 0x0 -f images/sector.bin -a 0x1000 -f images/fifty_kb.bin"
)
try:
assert "Successfully created esp8266 image." in output
assert os.path.exists("test0x00000.bin")
self.verify_image(16, 4096, "test0x00000.bin", "images/sector.bin")
self.verify_image(
4096 + 24, 50 * 1024, "test0x00000.bin", "images/fifty_kb.bin"
)
finally:
os.remove("test0x00000.bin")
@pytest.mark.skipif(arg_chip != "esp32", reason="Don't need to test multiple times")
@pytest.mark.quick_test
class TestConfigFile(EsptoolTestCase):
class ConfigFile:
"""
A class-based context manager to create
a custom config file and delete it after usage.
"""
def __init__(self, file_path, file_content):
self.file_path = file_path
self.file_content = file_content
def __enter__(self):
with open(self.file_path, "w") as cfg_file:
cfg_file.write(self.file_content)
return cfg_file
def __exit__(self, exc_type, exc_value, exc_tb):
os.unlink(self.file_path)
assert not os.path.exists(self.file_path)
dummy_config = (
"[esptool]\n"
"connect_attempts = 5\n"
"reset_delay = 1\n"
"serial_write_timeout = 12"
)
@pytest.mark.host_test
def test_load_config_file(self):
# Test a valid file is loaded
config_file_path = os.path.join(os.getcwd(), "esptool.cfg")
with self.ConfigFile(config_file_path, self.dummy_config):
output = self.run_esptool("version")
assert f"Loaded custom configuration from {config_file_path}" in output
assert "Ignoring unknown config file option" not in output
assert "Ignoring invalid config file" not in output
# Test invalid files are ignored
# Wrong section header, no config gets loaded
with self.ConfigFile(config_file_path, "[wrong section name]"):
output = self.run_esptool("version")
assert f"Loaded custom configuration from {config_file_path}" not in output
# Correct header, but options are unparseable
faulty_config = "[esptool]\n" "connect_attempts = 5\n" "connect_attempts = 9\n"
with self.ConfigFile(config_file_path, faulty_config):
output = self.run_esptool("version")
assert f"Ignoring invalid config file {config_file_path}" in output
assert (
"option 'connect_attempts' in section 'esptool' already exists"
in output
)
# Correct header, unknown option (or a typo)
faulty_config = "[esptool]\n" "connect_attempts = 9\n" "timout = 2\n" "bits = 2"
with self.ConfigFile(config_file_path, faulty_config):
output = self.run_esptool("version")
assert "Ignoring unknown config file options: bits, timout" in output
# Test other config files (setup.cfg, tox.ini) are loaded
config_file_path = os.path.join(os.getcwd(), "tox.ini")
with self.ConfigFile(config_file_path, self.dummy_config):
output = self.run_esptool("version")
assert f"Loaded custom configuration from {config_file_path}" in output
@pytest.mark.host_test
def test_load_config_file_with_env_var(self):
config_file_path = os.path.join(TEST_DIR, "custom_file.ini")
with self.ConfigFile(config_file_path, self.dummy_config):
# Try first without setting the env var, check that no config gets loaded
output = self.run_esptool("version")
assert f"Loaded custom configuration from {config_file_path}" not in output
# Set the env var and try again, check that config was loaded
tmp = os.environ.get("ESPTOOL_CFGFILE") # Save the env var if it is set
os.environ["ESPTOOL_CFGFILE"] = config_file_path
output = self.run_esptool("version")
assert f"Loaded custom configuration from {config_file_path}" in output
assert "(set with ESPTOOL_CFGFILE)" in output
if tmp is not None: # Restore the env var or unset it
os.environ["ESPTOOL_CFGFILE"] = tmp
else:
os.environ.pop("ESPTOOL_CFGFILE", None)
def test_custom_reset_sequence(self):
# This reset sequence will fail to reset the chip to bootloader,
# the flash_id operation should therefore fail.
# Also tests the number of connection attempts.
reset_seq_config = (
"[esptool]\n"
"custom_reset_sequence = D0|W0.1|R1|R0|W0.1|R1|R0\n"
"connect_attempts = 1\n"
)
config_file_path = os.path.join(os.getcwd(), "esptool.cfg")
with self.ConfigFile(config_file_path, reset_seq_config):
output = self.run_esptool_error("flash_id")
assert f"Loaded custom configuration from {config_file_path}" in output
assert "A fatal error occurred: Failed to connect to" in output
# Connection attempts are represented with dots,
# there are enough dots for two attempts here, but only one is executed
assert "Connecting............." not in output
# Test invalid custom_reset_sequence format is not accepted
invalid_reset_seq_config = "[esptool]\n" "custom_reset_sequence = F0|R1|C0|A5\n"
with self.ConfigFile(config_file_path, invalid_reset_seq_config):
output = self.run_esptool_error("flash_id")
assert f"Loaded custom configuration from {config_file_path}" in output
assert 'Invalid "custom_reset_sequence" option format:' in output
| 52,187 | Python | .py | 1,123 | 36.972395 | 88 | 0.621482 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,582 | test_imagegen.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/test_imagegen.py | import hashlib
import os
import os.path
import struct
import subprocess
import sys
from conftest import need_to_install_package_err
from elftools.elf.elffile import ELFFile
import pytest
TEST_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "elf2image")
try:
import esptool
except ImportError:
need_to_install_package_err()
def try_delete(path):
try:
os.remove(path)
except OSError:
pass
def segment_matches_section(segment, section):
"""segment is an ImageSegment from an esptool binary.
section is an elftools ELF section
Returns True if they match
"""
sh_size = (section.header.sh_size + 0x3) & ~3 # pad length of ELF sections
return section.header.sh_addr == segment.addr and sh_size == len(segment.data)
@pytest.mark.host_test
class BaseTestCase:
@classmethod
def setup_class(self):
# Save the current working directory to be resotred later
self.stored_dir = os.getcwd()
os.chdir(TEST_DIR)
@classmethod
def teardown_class(self):
# Restore the stored working directory
os.chdir(self.stored_dir)
def assertEqualHex(self, expected, actual, message=None):
try:
expected = hex(expected)
except TypeError: # if expected is character
expected = hex(ord(expected))
try:
actual = hex(actual)
except TypeError: # if actual is character
actual = hex(ord(actual))
assert expected == actual, message
def assertImageDoesNotContainSection(self, image, elf, section_name):
"""
Assert an esptool binary image object does not
contain the data for a particular ELF section.
"""
with open(elf, "rb") as f:
e = ELFFile(f)
section = e.get_section_by_name(section_name)
assert section, f"{section_name} should be in the ELF"
sh_addr = section.header.sh_addr
data = section.data()
# no section should start at the same address as the ELF section.
for seg in sorted(image.segments, key=lambda s: s.addr):
print(
f"comparing seg {seg.addr:#x} sec {sh_addr:#x} len {len(data):#x}"
)
assert (
seg.addr != sh_addr
), f"{section_name} should not be in the binary image"
def assertImageContainsSection(self, image, elf, section_name):
"""
Assert an esptool binary image object contains
the data for a particular ELF section.
"""
with open(elf, "rb") as f:
e = ELFFile(f)
section = e.get_section_by_name(section_name)
assert section, f"{section_name} should be in the ELF"
sh_addr = section.header.sh_addr
data = section.data()
# section contents may be smeared across multiple image segments,
# so look through each segment and remove it from ELF section 'data'
# as we find it in the image segments. When we're done 'data' should
# all be accounted for
for seg in sorted(image.segments, key=lambda s: s.addr):
print(
f"comparing seg {seg.addr:#x} sec {sh_addr:#x} len {len(data):#x}"
)
if seg.addr == sh_addr:
overlap_len = min(len(seg.data), len(data))
assert (
data[:overlap_len] == seg.data[:overlap_len]
), f"ELF '{section_name}' section has mis-matching bin image data"
sh_addr += overlap_len
data = data[overlap_len:]
# no bytes in 'data' should be left unmatched
assert len(data) == 0, (
f"ELF {elf} section '{section_name}' has no encompassing"
f" segment(s) in bin image (image segments: {image.segments})"
)
def assertImageInfo(self, binpath, chip="esp8266"):
"""
Run esptool.py image_info on a binary file,
assert no red flags about contents.
"""
cmd = [sys.executable, "-m", "esptool", "--chip", chip, "image_info", binpath]
try:
output = subprocess.check_output(cmd)
output = output.decode("utf-8")
print(output)
except subprocess.CalledProcessError as e:
print(e.output)
raise
assert "invalid" not in output, "Checksum calculation should be valid"
assert (
"warning" not in output.lower()
), "Should be no warnings in image_info output"
def run_elf2image(self, chip, elf_path, version=None, extra_args=[]):
"""Run elf2image on elf_path"""
cmd = [sys.executable, "-m", "esptool", "--chip", chip, "elf2image"]
if version is not None:
cmd += ["--version", str(version)]
cmd += [elf_path] + extra_args
print("\nExecuting {}".format(" ".join(cmd)))
try:
output = subprocess.check_output(cmd)
output = output.decode("utf-8")
print(output)
assert (
"warning" not in output.lower()
), "elf2image should not output warnings"
except subprocess.CalledProcessError as e:
print(e.output)
raise
class TestESP8266V1Image(BaseTestCase):
ELF = "esp8266-nonosssdk20-iotdemo.elf"
BIN_LOAD = "esp8266-nonosssdk20-iotdemo.elf-0x00000.bin"
BIN_IROM = "esp8266-nonosssdk20-iotdemo.elf-0x10000.bin"
@classmethod
def setup_class(self):
super(TestESP8266V1Image, self).setup_class()
self.run_elf2image(self, "esp8266", self.ELF, 1)
@classmethod
def teardown_class(self):
super(TestESP8266V1Image, self).teardown_class()
try_delete(self.BIN_LOAD)
try_delete(self.BIN_IROM)
def test_irom_bin(self):
with open(self.ELF, "rb") as f:
e = ELFFile(f)
irom_section = e.get_section_by_name(".irom0.text")
assert (
irom_section.header.sh_size == os.stat(self.BIN_IROM).st_size
), "IROM raw binary file should be same length as .irom0.text section"
def test_loaded_sections(self):
image = esptool.bin_image.LoadFirmwareImage("esp8266", self.BIN_LOAD)
# Adjacent sections are now merged, len(image.segments) should
# equal 2 (instead of 3).
assert len(image.segments) == 2
self.assertImageContainsSection(image, self.ELF, ".data")
self.assertImageContainsSection(image, self.ELF, ".text")
# Section .rodata is merged in the binary with the previous one,
# so it won't be found in the binary image.
self.assertImageDoesNotContainSection(image, self.ELF, ".rodata")
class TestESP8266V12SectionHeaderNotAtEnd(BaseTestCase):
"""Ref https://github.com/espressif/esptool/issues/197 -
this ELF image has the section header not at the end of the file"""
ELF = "esp8266-nonossdkv12-example.elf"
BIN_LOAD = ELF + "-0x00000.bin"
BIN_IROM = ELF + "-0x40000.bin"
@classmethod
def teardown_class(self):
try_delete(self.BIN_LOAD)
try_delete(self.BIN_IROM)
def test_elf_section_header_not_at_end(self):
self.run_elf2image("esp8266", self.ELF)
image = esptool.bin_image.LoadFirmwareImage("esp8266", self.BIN_LOAD)
assert len(image.segments) == 3
self.assertImageContainsSection(image, self.ELF, ".data")
self.assertImageContainsSection(image, self.ELF, ".text")
self.assertImageContainsSection(image, self.ELF, ".rodata")
class TestESP8266V2Image(BaseTestCase):
def _test_elf2image(self, elfpath, binpath, mergedsections=[]):
try:
self.run_elf2image("esp8266", elfpath, 2)
image = esptool.bin_image.LoadFirmwareImage("esp8266", binpath)
print("In test_elf2image", len(image.segments))
assert 4 - len(mergedsections) == len(image.segments)
sections = [".data", ".text", ".rodata"]
# Remove the merged sections from the `sections` list
sections = [sec for sec in sections if sec not in mergedsections]
for sec in sections:
self.assertImageContainsSection(image, elfpath, sec)
for sec in mergedsections:
self.assertImageDoesNotContainSection(image, elfpath, sec)
irom_segment = image.segments[0]
assert irom_segment.addr == 0, "IROM segment 'load address' should be zero"
with open(elfpath, "rb") as f:
e = ELFFile(f)
sh_size = (
e.get_section_by_name(".irom0.text").header.sh_size + 15
) & ~15
assert len(irom_segment.data) == sh_size, (
f"irom segment ({len(irom_segment.data):#x}) should be same size "
f"(16 padded) as .irom0.text section ({sh_size:#x})"
)
# check V2 CRC (for ESP8266 SDK bootloader)
with open(binpath, "rb") as f:
f.seek(-4, os.SEEK_END)
image_len = f.tell()
crc_stored = struct.unpack("<I", f.read(4))[0]
f.seek(0)
crc_calc = esptool.bin_image.esp8266_crc32(f.read(image_len))
assert crc_stored == crc_calc
# test imageinfo doesn't fail
self.assertImageInfo(binpath)
finally:
try_delete(binpath)
def test_nonossdkimage(self):
ELF = "esp8266-nonossdkv20-at-v2.elf"
BIN = "esp8266-nonossdkv20-at-v2-0x01000.bin"
self._test_elf2image(ELF, BIN)
def test_espopenrtosimage(self):
ELF = "esp8266-openrtos-blink-v2.elf"
BIN = "esp8266-openrtos-blink-v2-0x02000.bin"
# .rodata section is merged with the previous one: .data
self._test_elf2image(ELF, BIN, [".rodata"])
class TestESP32Image(BaseTestCase):
def _test_elf2image(self, elfpath, binpath, extra_args=[]):
try:
self.run_elf2image("esp32", elfpath, extra_args=extra_args)
image = esptool.bin_image.LoadFirmwareImage("esp32", binpath)
self.assertImageInfo(binpath, "esp32")
return image
finally:
try_delete(binpath)
def test_bootloader(self):
ELF = "esp32-bootloader.elf"
BIN = "esp32-bootloader.bin"
image = self._test_elf2image(ELF, BIN)
assert len(image.segments) == 3
for section in [".iram1.text", ".iram_pool_1.text", ".dram0.rodata"]:
self.assertImageContainsSection(image, ELF, section)
def test_app_template(self):
ELF = "esp32-app-template.elf"
BIN = "esp32-app-template.bin"
image = self._test_elf2image(ELF, BIN)
# Adjacent sections are now merged, len(image.segments) should
# equal 5 (instead of 6).
assert len(image.segments) == 5
# the other segment is a padding or merged segment
for section in [
".iram0.vectors",
".dram0.data",
".flash.rodata",
".flash.text",
]:
self.assertImageContainsSection(image, ELF, section)
# check that merged sections are not in the binary image
for mergedsection in [".iram0.text"]:
self.assertImageDoesNotContainSection(image, ELF, mergedsection)
def test_too_many_sections(self, capsys):
ELF = "esp32-too-many-sections.elf"
BIN = "esp32-too-many-sections.bin"
with pytest.raises(subprocess.CalledProcessError):
self._test_elf2image(ELF, BIN)
output = capsys.readouterr().out
assert "max 16" in output
assert "linker script" in output
def test_use_segments(self):
ELF = "esp32-zephyr.elf"
BIN = "esp32-zephyr.bin"
# default behaviour uses ELF sections,
# this ELF will produce 8 segments in the bin
image = self._test_elf2image(ELF, BIN)
# Adjacent sections are now merged, len(image.segments) should
# equal 4 (instead of 8).
assert len(image.segments) == 4
# --use_segments uses ELF segments(phdrs), produces just 2 segments in the bin
image = self._test_elf2image(ELF, BIN, ["--use_segments"])
assert len(image.segments) == 2
class TestESP8266FlashHeader(BaseTestCase):
def test_2mb(self):
ELF = "esp8266-nonossdkv20-at-v2.elf"
BIN = "esp8266-nonossdkv20-at-v2-0x01000.bin"
try:
self.run_elf2image(
"esp8266",
ELF,
version=2,
extra_args=["--flash_size", "2MB", "--flash_mode", "dio"],
)
with open(BIN, "rb") as f:
header = f.read(4)
print(f"header {header}")
self.assertEqualHex(0xEA, header[0])
self.assertEqualHex(0x02, header[2])
self.assertEqualHex(0x30, header[3])
finally:
try_delete(BIN)
class TestESP32FlashHeader(BaseTestCase):
def test_16mb(self):
ELF = "esp32-app-template.elf"
BIN = "esp32-app-template.bin"
try:
self.run_elf2image(
"esp32",
ELF,
extra_args=[
"--flash_size",
"16MB",
"--flash_mode",
"dio",
"--min-rev",
"1",
],
)
with open(BIN, "rb") as f:
header = f.read(24)
self.assertEqualHex(0xE9, header[0])
self.assertEqualHex(0x02, header[2])
self.assertEqualHex(0x40, header[3])
self.assertEqualHex(0x01, header[14]) # chip revision
finally:
try_delete(BIN)
class TestELFSHA256(BaseTestCase):
ELF = "esp32-app-cust-ver-info.elf"
SHA_OFFS = 0xB0 # absolute offset of the SHA in the .bin file
BIN = "esp32-app-cust-ver-info.bin"
"""
esp32-app-cust-ver-info.elf was built with the following application version info:
const __attribute__((section(".rodata_desc"))) esp_app_desc_t esp_app_desc = {
.magic_word = 0xffffffff,
.secure_version = 0xffffffff,
.reserv1 = {0xffffffff, 0xffffffff},
.version = "_______________________________",
.project_name = "-------------------------------",
.time = "xxxxxxxxxxxxxxx",
.date = "yyyyyyyyyyyyyyy",
.idf_ver = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
.app_elf_sha256 =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
.reserv2 = {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff},
};
This leaves zeroes only for the fiels of SHA-256 and the test will fail
if the placement of zeroes are tested at the wrong place.
00000000: e907 0020 780f 0840 ee00 0000 0000 0000 ... x..@........
00000010: 0000 0000 0000 0001 2000 403f 605a 0000 ........ .@?`Z..
00000020: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000030: 5f5f 5f5f 5f5f 5f5f 5f5f 5f5f 5f5f 5f5f ________________
00000040: 5f5f 5f5f 5f5f 5f5f 5f5f 5f5f 5f5f 5f00 _______________.
00000050: 2d2d 2d2d 2d2d 2d2d 2d2d 2d2d 2d2d 2d2d ----------------
00000060: 2d2d 2d2d 2d2d 2d2d 2d2d 2d2d 2d2d 2d00 ---------------.
00000070: 7878 7878 7878 7878 7878 7878 7878 7800 xxxxxxxxxxxxxxx.
00000080: 7979 7979 7979 7979 7979 7979 7979 7900 yyyyyyyyyyyyyyy.
00000090: 7a7a 7a7a 7a7a 7a7a 7a7a 7a7a 7a7a 7a7a zzzzzzzzzzzzzzzz
000000a0: 7a7a 7a7a 7a7a 7a7a 7a7a 7a7a 7a7a 7a00 zzzzzzzzzzzzzzz.
000000b0: 0000 0000 0000 0000 0000 0000 0000 0000 ................ SHA-256 here
000000c0: 0000 0000 0000 0000 0000 0000 0000 0000 ................
000000d0: ffff ffff ffff ffff ffff ffff ffff ffff ................
000000e0: ffff ffff ffff ffff ffff ffff ffff ffff ................
000000f0: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000100: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000110: ffff ffff ffff ffff ffff ffff ffff ffff ................
00000120: 6370 755f 7374 6172 7400 0000 1b5b 303b cpu_start....[0;
"""
def test_binary_patched(self):
try:
self.run_elf2image(
"esp32",
self.ELF,
extra_args=["--elf-sha256-offset", f"{self.SHA_OFFS:#x}"],
)
image = esptool.bin_image.LoadFirmwareImage("esp32", self.BIN)
rodata_segment = image.segments[0]
bin_sha256 = rodata_segment.data[
self.SHA_OFFS - 0x20 : self.SHA_OFFS - 0x20 + 32
] # subtract 0x20 byte header here
with open(self.ELF, "rb") as f:
elf_computed_sha256 = hashlib.sha256(f.read()).digest()
with open(self.BIN, "rb") as f:
f.seek(self.SHA_OFFS)
bin_sha256_raw = f.read(len(elf_computed_sha256))
assert elf_computed_sha256 == bin_sha256
assert elf_computed_sha256 == bin_sha256_raw
finally:
try_delete(self.BIN)
def test_no_overwrite_data(self, capsys):
with pytest.raises(subprocess.CalledProcessError):
self.run_elf2image(
"esp32",
"esp32-bootloader.elf",
extra_args=["--elf-sha256-offset", "0xb0"],
)
output = capsys.readouterr().out
assert "SHA256" in output
assert "zero" in output
class TestHashAppend(BaseTestCase):
ELF = "esp32-bootloader.elf"
BIN = "esp32-bootloader.bin"
# 15th byte of the extended header after the 8-byte image header
HASH_APPEND_OFFSET = 15 + 8
@classmethod
def teardown_class(self):
try_delete(self.BIN)
def test_hash_append(self):
self.run_elf2image(
"esp32",
self.ELF,
extra_args=["-o", self.BIN],
)
with open(self.BIN, "rb") as f:
bin_with_hash = f.read()
assert bin_with_hash[self.HASH_APPEND_OFFSET] == 1
# drop the last 32 bytes (SHA256 digest)
expected_bin_without_hash = bytearray(bin_with_hash[:-32])
# disable the hash append byte in the file header
expected_bin_without_hash[self.HASH_APPEND_OFFSET] = 0
try_delete(self.BIN)
self.run_elf2image(
"esp32",
self.ELF,
extra_args=["--dont-append-digest", "-o", self.BIN],
)
with open(self.BIN, "rb") as f:
bin_without_hash = f.read()
assert bin_without_hash[self.HASH_APPEND_OFFSET] == 0
assert bytes(expected_bin_without_hash) == bin_without_hash
| 19,223 | Python | .py | 429 | 34.365967 | 87 | 0.588527 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,583 | efuse_burn1.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/efuse_burn1.py | # flake8: noqa
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import json
config = json.load(args.configfiles[0])
assert args.index == 10, "Index should be 10"
for cmd in config["burn_efuses1"]:
cmd = cmd.format(index=args.index)
print(cmd)
espefuse(esp, efuses, args, cmd)
assert args.index == 10, "Index should be 10"
| 409 | Python | .py | 12 | 31.583333 | 71 | 0.736573 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,584 | efuse_burn2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/efuse_burn2.py | # flake8: noqa
# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import json
config = json.load(args.configfiles[0])
assert args.index == 28, "Should be index from the first script = 28"
for cmd in config["burn_efuses2"]:
cmd = cmd.format(index=args.index)
print(cmd)
espefuse(esp, efuses, args, cmd)
assert args.index == 28, "Should be index from the first script = 28"
| 457 | Python | .py | 12 | 35.583333 | 71 | 0.738041 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,585 | execute_efuse_script2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/esp32xx/execute_efuse_script2.py | # flake8: noqa
# fmt: off
espefuse(esp, efuses, args, 'burn_efuse DIS_FORCE_DOWNLOAD 1 DIS_CAN 1 DIS_DOWNLOAD_MODE 1')
if efuses["DIS_FORCE_DOWNLOAD"].get() != 0:
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, 'burn_bit BLOCK_USR_DATA 64 66 69 72 78 82 83 90')
if efuses["BLOCK_USR_DATA"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, 'read_protect_efuse BLOCK_SYS_DATA2')
espefuse(esp, efuses, args, 'write_protect_efuse BLOCK_SYS_DATA2')
if not efuses["BLOCK_SYS_DATA2"].is_readable() or not efuses["BLOCK_SYS_DATA2"].is_writeable():
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, 'burn_block_data BLOCK_KEY5 ../../images/efuse/256bit')
if efuses["BLOCK_KEY5"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, 'burn_key BLOCK_KEY0 ../../images/efuse/256bit XTS_AES_128_KEY --no-read-protect')
if efuses["BLOCK_KEY0"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
if not efuses["BLOCK_KEY0"].is_readable() or not efuses["BLOCK_KEY0"].is_writeable():
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, 'burn_key_digest BLOCK_KEY1 ../../secure_images/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST0')
if efuses["BLOCK_KEY1"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
if not efuses["BLOCK_KEY1"].is_readable() or not efuses["BLOCK_KEY1"].is_writeable():
raise esptool.FatalError("Burn should be at the end")
| 2,001 | Python | .py | 25 | 77.56 | 143 | 0.711314 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,586 | execute_efuse_script.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/esp32xx/execute_efuse_script.py | # flake8: noqa
# fmt: off
espefuse(esp, efuses, args, 'burn_efuse DIS_FORCE_DOWNLOAD 1 DIS_CAN 1 DIS_DOWNLOAD_MODE 1')
espefuse(esp, efuses, args, 'burn_bit BLOCK_USR_DATA 64 66 69 72 78 82 83 90')
espefuse(esp, efuses, args, 'read_protect_efuse BLOCK_SYS_DATA2')
espefuse(esp, efuses, args, 'write_protect_efuse BLOCK_SYS_DATA2')
espefuse(esp, efuses, args, 'burn_block_data BLOCK_KEY5 ../../images/efuse/256bit')
espefuse(esp, efuses, args, 'burn_key BLOCK_KEY0 ../../images/efuse/256bit XTS_AES_128_KEY --no-read-protect')
espefuse(esp, efuses, args, 'burn_key_digest BLOCK_KEY1 ../../secure_images/rsa_secure_boot_signing_key.pem SECURE_BOOT_DIGEST0')
efuses.burn_all()
espefuse(esp, efuses, args, 'summary')
espefuse(esp, efuses, args, 'adc_info')
# Checks written eFuses
if efuses["DIS_FORCE_DOWNLOAD"].get() != 1:
raise esptool.FatalError("DIS_FORCE_DOWNLOAD was not set")
if efuses["DIS_CAN"].get() != 1:
raise esptool.FatalError("DIS_CAN was not set")
if efuses["DIS_DOWNLOAD_MODE"].get() != 1:
raise esptool.FatalError("DIS_DOWNLOAD_MODE was not set")
if efuses["BLOCK_USR_DATA"].get_meaning() != "00 00 00 00 00 00 00 00 25 41 0c 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("BLOCK_USR_DATA was not set correctly")
if efuses["BLOCK_SYS_DATA2"].is_readable() or efuses["BLOCK_SYS_DATA2"].is_writeable():
raise esptool.FatalError("BLOCK_SYS_DATA2 should be read and write protected")
if efuses["BLOCK_KEY5"].get_meaning() != "a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf":
raise esptool.FatalError("BLOCK_KEY5 was not set correctly")
if efuses["BLOCK_KEY0"].get_meaning() != "bf be bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae ad ac ab aa a9 a8 a7 a6 a5 a4 a3 a2 a1 a0":
raise esptool.FatalError("BLOCK_KEY0 was not set correctly")
if not efuses["BLOCK_KEY0"].is_readable() or efuses["BLOCK_KEY0"].is_writeable():
raise esptool.FatalError("BLOCK_KEY0 should be readable and not writable")
if efuses["KEY_PURPOSE_0"].get_meaning() != "XTS_AES_128_KEY":
raise esptool.FatalError("KEY_PURPOSE_0 was not set XTS_AES_128_KEY")
if efuses["KEY_PURPOSE_0"].is_writeable():
raise esptool.FatalError("KEY_PURPOSE_0 should be write-protected")
if efuses["BLOCK_KEY1"].get_meaning() != "cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63":
raise esptool.FatalError("BLOCK_KEY1 was not set correctly")
if efuses["KEY_PURPOSE_1"].get_meaning() != "SECURE_BOOT_DIGEST0":
raise esptool.FatalError("KEY_PURPOSE_1 was not set SECURE_BOOT_DIGEST0")
if efuses["KEY_PURPOSE_1"].is_writeable():
raise esptool.FatalError("KEY_PURPOSE_1 should be write-protected")
if not efuses["BLOCK_KEY1"].is_readable() or efuses["BLOCK_KEY1"].is_writeable():
raise esptool.FatalError("BLOCK_KEY1 should be readable and not writable")
espefuse(esp, efuses, args, 'burn_key BLOCK_KEY0 ../../images/efuse/256bit XTS_AES_128_KEY')
efuses.burn_all()
if efuses["BLOCK_KEY0"].is_readable() or efuses["BLOCK_KEY0"].is_writeable():
raise esptool.FatalError("BLOCK_KEY0 should be not readable and not writeable")
| 3,201 | Python | .py | 45 | 68.333333 | 143 | 0.724402 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,587 | execute_efuse_script2.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/esp32/execute_efuse_script2.py | # flake8: noqa
# fmt: off
espefuse(esp, efuses, args, "burn_efuse JTAG_DISABLE 1 DISABLE_SDIO_HOST 1 CONSOLE_DEBUG_DISABLE 1")
if efuses["JTAG_DISABLE"].get() != 0:
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, "burn_key flash_encryption ../../images/efuse/256bit --no-protect-key")
if efuses["BLOCK1"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
if not efuses["BLOCK1"].is_readable() or not efuses["BLOCK1"].is_writeable():
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, "burn_key_digest ../../secure_images/rsa_secure_boot_signing_key.pem")
if efuses["BLOCK2"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
if not efuses["BLOCK2"].is_readable() or not efuses["BLOCK2"].is_writeable():
raise esptool.FatalError("Burn should be at the end")
espefuse(esp, efuses, args, "burn_bit BLOCK3 64 66 69 72 78 82 83 90")
espefuse(esp, efuses, args, "burn_custom_mac AA:BB:CC:DD:EE:88")
if efuses["BLOCK3"].get_meaning() != "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00":
raise esptool.FatalError("Burn should be at the end")
| 1,416 | Python | .py | 19 | 72.052632 | 135 | 0.705671 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,588 | execute_efuse_script.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/test/efuse_scripts/esp32/execute_efuse_script.py | # flake8: noqa
# fmt: off
espefuse(esp, efuses, args, "burn_efuse JTAG_DISABLE 1 DISABLE_SDIO_HOST 1 CONSOLE_DEBUG_DISABLE 1")
espefuse(esp, efuses, args, "burn_key flash_encryption ../../images/efuse/256bit --no-protect-key")
espefuse(esp, efuses, args, "burn_key_digest ../../secure_images/rsa_secure_boot_signing_key.pem")
espefuse(esp, efuses, args, "burn_bit BLOCK3 64 66 69 72 78 82 83 90")
espefuse(esp, efuses, args, "burn_custom_mac AA:BB:CC:DD:EE:88")
efuses.burn_all()
espefuse(esp, efuses, args, "summary")
espefuse(esp, efuses, args, "adc_info")
espefuse(esp, efuses, args, "get_custom_mac")
# Checks written eFuses
if efuses["JTAG_DISABLE"].get() != 1:
raise esptool.FatalError("JTAG_DISABLE was not set")
if efuses["DISABLE_SDIO_HOST"].get() != 1:
raise esptool.FatalError("DISABLE_SDIO_HOST was not set")
if efuses["CONSOLE_DEBUG_DISABLE"].get() != 1:
raise esptool.FatalError("CONSOLE_DEBUG_DISABLE was not set")
if efuses["BLOCK1"].get_meaning() != "bf be bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae ad ac ab aa a9 a8 a7 a6 a5 a4 a3 a2 a1 a0":
raise esptool.FatalError("BLOCK1 was not set correctly")
if not efuses["BLOCK1"].is_readable() or not efuses["BLOCK1"].is_writeable():
raise esptool.FatalError("BLOCK1 should be readable and writeable")
if efuses["BLOCK2"].get_meaning() != "cb 27 91 a3 71 b0 c0 32 2b f7 37 04 78 ba 09 62 22 4c ab 1c f2 28 78 79 e4 29 67 3e 7d a8 44 63":
raise esptool.FatalError("BLOCK2 was not set correctly")
if not efuses["BLOCK2"].is_readable() or efuses["BLOCK2"].is_writeable():
raise esptool.FatalError("BLOCK2 should not be readable and not writeable")
if efuses["BLOCK3"].get_meaning() != "69 aa bb cc dd ee 88 00 25 41 0c 04 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00":
raise esptool.FatalError("BLOCK3 was not set correctly")
if efuses["CUSTOM_MAC"].get_meaning() != "aa:bb:cc:dd:ee:88 (CRC 0x69 OK)":
raise esptool.FatalError("CUSTOM_MAC was not set correctly")
espefuse(esp, efuses, args, "read_protect_efuse BLOCK1")
espefuse(esp, efuses, args, "write_protect_efuse BLOCK1")
efuses.burn_all()
if efuses["BLOCK1"].is_readable() or efuses["BLOCK1"].is_writeable():
raise esptool.FatalError("BLOCK_KEY0 should be not readable and not writeable")
| 2,280 | Python | .py | 35 | 62.571429 | 135 | 0.72287 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,589 | esptool_test_stub.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/flasher_stub/esptool_test_stub.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
#
# Trivial wrapper program to run esptool.py using the just-compiled
# flasher stub in the build/ subdirectory
#
# For use when developing new flasher_stubs, not important otherwise.
import os.path
import sys
THIS_DIR = os.path.dirname(__file__)
STUBS_BUILD_DIR = os.path.join(THIS_DIR, "build/")
sys.path.append("..")
import esptool # noqa: E402
# Python hackiness: change the path to stub json files in the context of the esptool
# module, so it edits the esptool's global variables
exec(
"loader.STUBS_DIR = '{}'".format(STUBS_BUILD_DIR),
esptool.__dict__,
esptool.__dict__,
)
if __name__ == "__main__":
try:
esptool.main()
except esptool.FatalError as e:
print("\nA fatal error occurred: %s" % e)
sys.exit(2)
| 971 | Python | .py | 30 | 29.7 | 84 | 0.712299 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,590 | wrap_stub.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/flasher_stub/wrap_stub.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2016 Cesanta Software Limited
#
# SPDX-License-Identifier: GPL-2.0-or-later
#
# SPDX-FileContributor: 2016-2022 Espressif Systems (Shanghai) CO LTD
import argparse
import base64
import json
import os
import os.path
import sys
sys.path.append("..")
import esptool # noqa: E402
THIS_DIR = os.path.dirname(__file__)
BUILD_DIR = os.path.join(THIS_DIR, "build")
def wrap_stub(elf_file):
"""Wrap an ELF file into a stub JSON dict"""
print("Wrapping ELF file %s..." % elf_file)
e = esptool.bin_image.ELFFile(elf_file)
text_section = e.get_section(".text")
stub = {
"entry": e.entrypoint,
"text": text_section.data,
"text_start": text_section.addr,
}
try:
data_section = e.get_section(".data")
stub["data"] = data_section.data
stub["data_start"] = data_section.addr
except ValueError:
pass
# Pad text with NOPs to mod 4.
if len(stub["text"]) % 4 != 0:
stub["text"] += (4 - (len(stub["text"]) % 4)) * "\0"
print(
"Stub text: %d @ 0x%08x, data: %d @ 0x%08x, entry @ 0x%x"
% (
len(stub["text"]),
stub["text_start"],
len(stub.get("data", "")),
stub.get("data_start", 0),
stub["entry"],
),
file=sys.stderr,
)
return stub
def write_json_files(stubs_dict):
class BytesEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, bytes):
return base64.b64encode(obj).decode("ascii")
return json.JSONEncoder.default(self, obj)
for filename, stub_data in stubs_dict.items():
with open(os.path.join(BUILD_DIR, filename), "w") as outfile:
json.dump(stub_data, outfile, cls=BytesEncoder, indent=4)
def stub_name(filename):
"""Return a dictionary key for the stub with filename 'filename'"""
return os.path.splitext(os.path.basename(filename))[0] + ".json"
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("elf_files", nargs="+", help="Stub ELF files to convert")
args = parser.parse_args()
stubs = dict(
(stub_name(elf_file), wrap_stub(elf_file)) for elf_file in args.elf_files
)
write_json_files(stubs)
| 2,318 | Python | .py | 68 | 28.058824 | 81 | 0.61828 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,591 | compare_stubs.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/flasher_stub/compare_stubs.py | #!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2014-2022 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import sys
import esptool
# Compare the esptool stub loaders to freshly built ones in the build directory
#
# (Used by CI to verify the stubs are up to date.)
THIS_SCRIPT_DIR = os.path.dirname(__file__)
STUB_DIR = "../esptool/targets/stub_flasher/"
BUILD_DIR = "build/"
JSON_NAME = "stub_flasher_{}.json"
def diff(path_to_new, path_to_old):
output = ""
new = esptool.loader.StubFlasher(path_to_new)
old = esptool.loader.StubFlasher(path_to_old)
if new.data_start != old.data_start:
output += " Data start: New {:#x}, old {:#x} \n".format(
new.data_start, old.data_start
)
if new.text_start != old.text_start:
output += " Text start: New {:#x}, old {:#x} \n".format(
new.text_start, old.text_start
)
if new.entry != old.entry:
output += " Entrypoint: New {:#x}, old {:#x} \n".format(new.entry, old.entry)
# data
if new.data != old.data:
if len(new.data) == len(old.data):
for i, (new_b, old_b) in enumerate(zip(new.data, old.data)):
if new_b != old_b:
output += " Data byte {:#x}: new {:#04x} old {:#04x} \n".format(
i, new_b, old_b
)
else:
output += " Data length: New {} bytes, old {} bytes \n".format(
len(new.data), len(old.data)
)
# text
if new.text != old.text:
if len(new.text) == len(old.text):
for i, (new_b, old_b) in enumerate(zip(new.text, old.text)):
if new_b != old_b:
output += " Text byte {:#x}: new {:#04x} old {:#04x} \n".format(
i, new_b, old_b
)
else:
output += " Text length: New {} bytes, old {} bytes \n".format(
len(new.text), len(old.text)
)
return output
if __name__ == "__main__":
same = True
for chip in esptool.CHIP_LIST:
print("Comparing {} stub: ".format(chip), end="")
chip = chip.replace("esp", "")
old = os.path.join(THIS_SCRIPT_DIR, STUB_DIR, JSON_NAME.format(chip))
new = os.path.join(THIS_SCRIPT_DIR, BUILD_DIR, JSON_NAME.format(chip))
output = diff(new, old)
if output != "":
same = False
print("FAIL")
print(
" Mismatch: {} json file in esptool/targets/stub_flasher/ differs "
"from the just-built stub".format("esp" + chip)
)
print(output)
else:
print("OK")
if not same:
sys.exit(1)
else:
print("Stub flasher json files are the same")
sys.exit(0)
| 2,928 | Python | .py | 78 | 28.615385 | 86 | 0.539492 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,592 | __main__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espsecure/__main__.py | # SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import espsecure
if __name__ == "__main__":
espsecure._main()
| 186 | Python | .py | 6 | 29 | 71 | 0.724719 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,593 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espsecure/__init__.py | # SPDX-FileCopyrightText: 2016-2023 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import hashlib
import operator
import os
import struct
import sys
import tempfile
import zlib
from collections import namedtuple
from cryptography import exceptions
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec, padding, rsa, utils
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.utils import int_to_bytes
import ecdsa
import esptool
SIG_BLOCK_MAGIC = 0xE7
# Scheme used in Secure Boot V2
SIG_BLOCK_VERSION_RSA = 0x02
SIG_BLOCK_VERSION_ECDSA = 0x03
# Curve IDs used in Secure Boot V2 ECDSA signature blocks
CURVE_ID_P192 = 1
CURVE_ID_P256 = 2
SECTOR_SIZE = 4096
SIG_BLOCK_SIZE = (
1216 # Refer to secure boot v2 signature block format for more details.
)
def get_chunks(source, chunk_len):
"""Returns an iterator over 'chunk_len' chunks of 'source'"""
return (source[i : i + chunk_len] for i in range(0, len(source), chunk_len))
def endian_swap_words(source):
"""Endian-swap each word in 'source' bitstring"""
assert len(source) % 4 == 0
words = "I" * (len(source) // 4)
return struct.pack("<" + words, *struct.unpack(">" + words, source))
def swap_word_order(source):
"""Swap the order of the words in 'source' bitstring"""
assert len(source) % 4 == 0
words = "I" * (len(source) // 4)
return struct.pack(words, *reversed(struct.unpack(words, source)))
def _load_hardware_key(keyfile):
"""Load a 128/256/512-bit key, similar to stored in efuse, from a file
128-bit keys will be extended to 256-bit using the SHA256 of the key
192-bit keys will be extended to 256-bit using the same algorithm used
by hardware if 3/4 Coding Scheme is set.
"""
key = keyfile.read()
if len(key) not in [16, 24, 32, 64]:
raise esptool.FatalError(
"Key file contains wrong length (%d bytes), 16, 24, 32 or 64 expected."
% len(key)
)
if len(key) == 16:
key = _sha256_digest(key)
print("Using 128-bit key (extended)")
elif len(key) == 24:
key = key + key[8:16]
assert len(key) == 32
print("Using 192-bit key (extended)")
elif len(key) == 32:
print("Using 256-bit key")
else:
print("Using 512-bit key")
return key
def digest_secure_bootloader(args):
"""Calculate the digest of a bootloader image, in the same way the hardware
secure boot engine would do so. Can be used with a pre-loaded key to update a
secure bootloader."""
_check_output_is_not_input(args.keyfile, args.output)
_check_output_is_not_input(args.image, args.output)
_check_output_is_not_input(args.iv, args.output)
if args.iv is not None:
print("WARNING: --iv argument is for TESTING PURPOSES ONLY")
iv = args.iv.read(128)
else:
iv = os.urandom(128)
plaintext_image = args.image.read()
args.image.seek(0)
# secure boot engine reads in 128 byte blocks (ie SHA512 block
# size), but also doesn't look for any appended SHA-256 digest
fw_image = esptool.bin_image.ESP32FirmwareImage(args.image)
if fw_image.append_digest:
if len(plaintext_image) % 128 <= 32:
# ROM bootloader will read to the end of the 128 byte block, but not
# to the end of the SHA-256 digest at the end
new_len = len(plaintext_image) - (len(plaintext_image) % 128)
plaintext_image = plaintext_image[:new_len]
# if image isn't 128 byte multiple then pad with 0xFF (ie unwritten flash)
# as this is what the secure boot engine will see
if len(plaintext_image) % 128 != 0:
plaintext_image += b"\xFF" * (128 - (len(plaintext_image) % 128))
plaintext = iv + plaintext_image
# Secure Boot digest algorithm in hardware uses AES256 ECB to
# produce a ciphertext, then feeds output through SHA-512 to
# produce the digest. Each block in/out of ECB is reordered
# (due to hardware quirks not for security.)
key = _load_hardware_key(args.keyfile)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend)
encryptor = cipher.encryptor()
digest = hashlib.sha512()
for block in get_chunks(plaintext, 16):
block = block[::-1] # reverse each input block
cipher_block = encryptor.update(block)
# reverse and then byte swap each word in the output block
cipher_block = cipher_block[::-1]
for block in get_chunks(cipher_block, 4):
# Python hashlib can build each SHA block internally
digest.update(block[::-1])
if args.output is None:
args.output = os.path.splitext(args.image.name)[0] + "-digest-0x0000.bin"
with open(args.output, "wb") as f:
f.write(iv)
digest = digest.digest()
for word in get_chunks(digest, 4):
f.write(word[::-1]) # swap word order in the result
f.write(b"\xFF" * (0x1000 - f.tell())) # pad to 0x1000
f.write(plaintext_image)
print("digest+image written to %s" % args.output)
def _generate_ecdsa_signing_key(curve_id, keyfile):
sk = ecdsa.SigningKey.generate(curve=curve_id)
with open(keyfile, "wb") as f:
f.write(sk.to_pem())
def generate_signing_key(args):
if os.path.exists(args.keyfile):
raise esptool.FatalError("ERROR: Key file %s already exists" % args.keyfile)
if args.version == "1":
if hasattr(args, "scheme"):
if args.scheme != "ecdsa256" and args.scheme is not None:
raise esptool.FatalError("ERROR: V1 only supports ECDSA256")
"""
Generate an ECDSA signing key for signing secure boot images (post-bootloader)
"""
_generate_ecdsa_signing_key(ecdsa.NIST256p, args.keyfile)
print("ECDSA NIST256p private key in PEM format written to %s" % args.keyfile)
elif args.version == "2":
if args.scheme == "rsa3072" or args.scheme is None:
"""Generate a RSA 3072 signing key for signing secure boot images"""
private_key = rsa.generate_private_key(
public_exponent=65537, key_size=3072, backend=default_backend()
).private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption(),
)
with open(args.keyfile, "wb") as f:
f.write(private_key)
print("RSA 3072 private key in PEM format written to %s" % args.keyfile)
elif args.scheme == "ecdsa192":
"""Generate a ECDSA 192 signing key for signing secure boot images"""
_generate_ecdsa_signing_key(ecdsa.NIST192p, args.keyfile)
print(
"ECDSA NIST192p private key in PEM format written to %s" % args.keyfile
)
elif args.scheme == "ecdsa256":
"""Generate a ECDSA 256 signing key for signing secure boot images"""
_generate_ecdsa_signing_key(ecdsa.NIST256p, args.keyfile)
print(
"ECDSA NIST256p private key in PEM format written to %s" % args.keyfile
)
else:
raise esptool.FatalError(
"ERROR: Unsupported signing scheme (%s)" % args.scheme
)
def load_ecdsa_signing_key(keyfile):
"""Load ECDSA signing key"""
try:
sk = ecdsa.SigningKey.from_pem(keyfile.read())
except ValueError:
raise esptool.FatalError(
"Incorrect ECDSA private key specified. "
"Please check algorithm and/or format."
)
if sk.curve not in [ecdsa.NIST192p, ecdsa.NIST256p]:
raise esptool.FatalError("Supports NIST192p and NIST256p keys only")
return sk
def _load_ecdsa_signing_key(keyfile):
"""Load ECDSA signing key for Secure Boot V1 only"""
sk = load_ecdsa_signing_key(keyfile)
if sk.curve != ecdsa.NIST256p:
raise esptool.FatalError(
"Signing key uses incorrect curve. ESP32 Secure Boot only supports "
"NIST256p (openssl calls this curve 'prime256v1')"
)
return sk
def _load_ecdsa_verifying_key(keyfile):
"""Load ECDSA verifying key for Secure Boot V1 only"""
try:
vk = ecdsa.VerifyingKey.from_pem(keyfile.read())
except ValueError:
raise esptool.FatalError(
"Incorrect ECDSA public key specified. "
"Please check algorithm and/or format."
)
if vk.curve != ecdsa.NIST256p:
raise esptool.FatalError(
"Signing key uses incorrect curve. ESP32 Secure Boot only supports "
"NIST256p (openssl calls this curve 'prime256v1')"
)
return vk
def _load_sbv2_signing_key(keydata):
"""
Load Secure Boot V2 signing key
can be rsa.RSAPrivateKey or ec.EllipticCurvePrivateKey
"""
sk = serialization.load_pem_private_key(
keydata, password=None, backend=default_backend()
)
if isinstance(sk, rsa.RSAPrivateKey):
if sk.key_size != 3072:
raise esptool.FatalError(
"Key file has length %d bits. Secure boot v2 only supports RSA-3072."
% sk.key_size
)
return sk
if isinstance(sk, ec.EllipticCurvePrivateKey):
if not (
isinstance(sk.curve, ec.SECP192R1) or isinstance(sk.curve, ec.SECP256R1)
):
raise esptool.FatalError(
"Key file uses incorrect curve. Secure Boot V2 + ECDSA only supports "
"NIST192p, NIST256p (aka prime192v1, prime256v1)"
)
return sk
raise esptool.FatalError("Unsupported signing key for Secure Boot V2")
def _load_sbv2_pub_key(keydata):
"""
Load Secure Boot V2 public key, can be rsa.RSAPublicKey or ec.EllipticCurvePublicKey
"""
vk = serialization.load_pem_public_key(keydata, backend=default_backend())
if isinstance(vk, rsa.RSAPublicKey):
if vk.key_size != 3072:
raise esptool.FatalError(
"Key file has length %d bits. Secure boot v2 only supports RSA-3072."
% vk.key_size
)
return vk
if isinstance(vk, ec.EllipticCurvePublicKey):
if not (
isinstance(vk.curve, ec.SECP192R1) or isinstance(vk.curve, ec.SECP256R1)
):
raise esptool.FatalError(
"Key file uses incorrect curve. Secure Boot V2 + ECDSA only supports "
"NIST192p, NIST256p (aka prime192v1, prime256v1)"
)
return vk
raise esptool.FatalError("Unsupported public key for Secure Boot V2")
def _get_sbv2_pub_key(keyfile):
key_data = keyfile.read()
if (
b"-BEGIN RSA PRIVATE KEY" in key_data
or b"-BEGIN EC PRIVATE KEY" in key_data
or b"-BEGIN PRIVATE KEY" in key_data
):
return _load_sbv2_signing_key(key_data).public_key()
elif b"-BEGIN PUBLIC KEY" in key_data:
vk = _load_sbv2_pub_key(key_data)
else:
raise esptool.FatalError(
"Verification key does not appear to be an RSA Private or "
"Public key in PEM format. Unsupported"
)
return vk
def _get_sbv2_rsa_primitives(public_key):
primitives = namedtuple("primitives", ["n", "e", "m", "rinv"])
numbers = public_key.public_numbers()
primitives.n = numbers.n #
primitives.e = numbers.e # two public key components
# Note: this cheats and calls a private 'rsa' method to get the modular
# inverse calculation.
primitives.m = -rsa._modinv(primitives.n, 1 << 32)
rr = 1 << (public_key.key_size * 2)
primitives.rinv = rr % primitives.n
return primitives
def _microecc_format(a, b, curve_len):
"""
Given two numbers (curve coordinates or (r,s) signature), write them out as a
little-endian byte sequence suitable for micro-ecc
"native little endian" mode
"""
byte_len = int(curve_len / 8)
ab = int_to_bytes(a, byte_len)[::-1] + int_to_bytes(b, byte_len)[::-1]
assert len(ab) == 48 or len(ab) == 64
return ab
def sign_data(args):
if args.keyfile:
_check_output_is_not_input(args.keyfile, args.output)
_check_output_is_not_input(args.datafile, args.output)
if args.version == "1":
return sign_secure_boot_v1(args)
elif args.version == "2":
return sign_secure_boot_v2(args)
def sign_secure_boot_v1(args):
"""
Sign a data file with a ECDSA private key, append binary signature to file contents
"""
binary_content = args.datafile.read()
if args.hsm:
raise esptool.FatalError(
"Secure Boot V1 does not support signing using an "
"external Hardware Security Module (HSM)"
)
if args.signature:
print("Pre-calculated signatures found")
if len(args.pub_key) > 1:
raise esptool.FatalError("Secure Boot V1 only supports one signing key")
signature = args.signature[0].read()
# get verifying/public key
vk = _load_ecdsa_verifying_key(args.pub_key[0])
else:
if len(args.keyfile) > 1:
raise esptool.FatalError("Secure Boot V1 only supports one signing key")
sk = _load_ecdsa_signing_key(args.keyfile[0])
# calculate signature of binary data
signature = sk.sign_deterministic(binary_content, hashlib.sha256)
# get verifying/public key
vk = sk.get_verifying_key()
# back-verify signature
vk.verify(signature, binary_content, hashlib.sha256) # throws exception on failure
if args.output is None or os.path.abspath(args.output) == os.path.abspath(
args.datafile.name
): # append signature to input file
args.datafile.close()
outfile = open(args.datafile.name, "ab")
else: # write file & signature to new file
outfile = open(args.output, "wb")
outfile.write(binary_content)
outfile.write(
struct.pack("I", 0)
) # Version indicator, allow for different curves/formats later
outfile.write(signature)
outfile.close()
print("Signed %d bytes of data from %s" % (len(binary_content), args.datafile.name))
def sign_secure_boot_v2(args):
"""
Sign a firmware app image with an RSA private key using RSA-PSS,
or ECDSA private key using P192 or P256.
Write output file with a Secure Boot V2 header appended.
"""
SIG_BLOCK_MAX_COUNT = 3
contents = args.datafile.read()
sig_block_num = 0
signature_sector = b""
signature = args.signature
pub_key = args.pub_key
if len(contents) % SECTOR_SIZE != 0:
if args.signature:
raise esptool.FatalError(
"Secure Boot V2 requires the signature block to start "
"from a 4KB aligned sector "
"but the datafile supplied is not sector aligned."
)
else:
pad_by = SECTOR_SIZE - (len(contents) % SECTOR_SIZE)
print(
f"Padding data contents by {pad_by} bytes "
"so signature sector aligns at sector boundary"
)
contents += b"\xff" * pad_by
elif args.append_signatures:
while sig_block_num < SIG_BLOCK_MAX_COUNT:
sig_block = validate_signature_block(contents, sig_block_num)
if sig_block is None:
break
signature_sector += (
sig_block # Signature sector is populated with already valid blocks
)
sig_block_num += 1
if len(signature_sector) % SIG_BLOCK_SIZE != 0:
raise esptool.FatalError("Incorrect signature sector size")
if sig_block_num == 0:
print(
"No valid signature blocks found. "
"Discarding --append-signature and proceeding to sign the image afresh."
)
else:
print(
f"{sig_block_num} valid signature block(s) already present "
"in the signature sector."
)
if sig_block_num == SIG_BLOCK_MAX_COUNT:
raise esptool.FatalError(
f"Upto {SIG_BLOCK_MAX_COUNT} signature blocks are supported. "
"(For ESP32-ECO3 only 1 signature block is supported)"
)
# Signature stripped off the content
# (the legitimate blocks are included in signature_sector)
contents = contents[: len(contents) - SECTOR_SIZE]
if args.hsm:
if args.hsm_config is None:
raise esptool.FatalError(
"Config file is required to generate signature using an external HSM."
)
import espsecure.esp_hsm_sign as hsm
try:
config = hsm.read_hsm_config(args.hsm_config)
except Exception as e:
raise esptool.FatalError(f"Incorrect HSM config file format ({e})")
if pub_key is None:
pub_key = extract_pubkey_from_hsm(config)
signature = generate_signature_using_hsm(config, contents)
if signature:
print("Pre-calculated signatures found")
key_count = len(pub_key)
if len(signature) != key_count:
raise esptool.FatalError(
f"Number of public keys ({key_count}) not equal to "
f"the number of signatures {len(signature)}."
)
else:
key_count = len(args.keyfile)
empty_signature_blocks = SIG_BLOCK_MAX_COUNT - sig_block_num
if key_count > empty_signature_blocks:
raise esptool.FatalError(
f"Number of keys({key_count}) more than the empty signature blocks."
f"({empty_signature_blocks})"
)
print(f"{key_count} signing key(s) found.")
# Calculate digest of data file
digest = hashlib.sha256()
digest.update(contents)
digest = digest.digest()
# Generate signature block using pre-calculated signatures
if signature:
signature_block = generate_signature_block_using_pre_calculated_signature(
signature, pub_key, digest
)
# Generate signature block by signing using private keys
else:
signature_block = generate_signature_block_using_private_key(
args.keyfile, digest
)
if signature_block is None or len(signature_block) == 0:
raise esptool.FatalError("Signature Block generation failed")
signature_sector += signature_block
if (
len(signature_sector) < 0
and len(signature_sector) > SIG_BLOCK_SIZE * 3
and len(signature_sector) % SIG_BLOCK_SIZE != 0
):
raise esptool.FatalError("Incorrect signature sector generation")
total_sig_blocks = len(signature_sector) // SIG_BLOCK_SIZE
# Pad signature_sector to sector
signature_sector = signature_sector + (
b"\xff" * (SECTOR_SIZE - len(signature_sector))
)
if len(signature_sector) != SECTOR_SIZE:
raise esptool.FatalError("Incorrect signature sector size")
# Write to output file, or append to existing file
if args.output is None:
args.datafile.close()
args.output = args.datafile.name
with open(args.output, "wb") as f:
f.write(contents + signature_sector)
print(
f"Signed {len(contents)} bytes of data from {args.datafile.name}. "
f"Signature sector now has {total_sig_blocks} signature blocks."
)
def generate_signature_using_hsm(config, contents):
import espsecure.esp_hsm_sign as hsm
session = hsm.establish_session(config)
# get the private key
private_key = hsm.get_privkey_info(session, config)
# Sign payload
signature = hsm.sign_payload(private_key, contents)
hsm.close_connection(session)
temp_signature_file = tempfile.TemporaryFile()
temp_signature_file.write(signature)
temp_signature_file.seek(0)
return [temp_signature_file]
def generate_signature_block_using_pre_calculated_signature(signature, pub_key, digest):
signature_blocks = b""
for sig, pk in zip(signature, pub_key):
try:
public_key = _get_sbv2_pub_key(pk)
signature = sig.read()
if isinstance(public_key, rsa.RSAPublicKey):
# RSA signature
rsa_primitives = _get_sbv2_rsa_primitives(public_key)
# Verify the signature
public_key.verify(
signature,
digest,
padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32),
utils.Prehashed(hashes.SHA256()),
)
signature_block = generate_rsa_signature_block(
digest, rsa_primitives, signature
)
else:
# ECDSA signature
numbers = public_key.public_numbers()
if isinstance(numbers.curve, ec.SECP192R1):
curve_len = 192
curve_id = CURVE_ID_P192
elif isinstance(numbers.curve, ec.SECP256R1):
curve_len = 256
curve_id = CURVE_ID_P256
else:
raise esptool.FatalError("Invalid ECDSA curve instance.")
# Verify the signature
public_key.verify(
signature, digest, ec.ECDSA(utils.Prehashed(hashes.SHA256()))
)
pubkey_point = _microecc_format(numbers.x, numbers.y, curve_len)
r, s = utils.decode_dss_signature(signature)
signature_rs = _microecc_format(r, s, curve_len)
signature_block = generate_ecdsa_signature_block(
digest, curve_id, pubkey_point, signature_rs
)
except exceptions.InvalidSignature:
raise esptool.FatalError(
"Signature verification failed: Invalid Signature\n"
"The pre-calculated signature has not been signed "
"using the given public key"
)
signature_block += struct.pack("<I", zlib.crc32(signature_block) & 0xFFFFFFFF)
signature_block += b"\x00" * 16 # padding
if len(signature_block) != SIG_BLOCK_SIZE:
raise esptool.FatalError("Incorrect signature block size")
signature_blocks += signature_block
return signature_blocks
def generate_signature_block_using_private_key(keyfiles, digest):
signature_blocks = b""
for keyfile in keyfiles:
private_key = _load_sbv2_signing_key(keyfile.read())
# Sign
if isinstance(private_key, rsa.RSAPrivateKey):
# RSA signature
signature = private_key.sign(
digest,
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=32,
),
utils.Prehashed(hashes.SHA256()),
)
rsa_primitives = _get_sbv2_rsa_primitives(private_key.public_key())
signature_block = generate_rsa_signature_block(
digest, rsa_primitives, signature
)
else:
# ECDSA signature
signature = private_key.sign(
digest, ec.ECDSA(utils.Prehashed(hashes.SHA256()))
)
numbers = private_key.public_key().public_numbers()
if isinstance(private_key.curve, ec.SECP192R1):
curve_len = 192
curve_id = CURVE_ID_P192
elif isinstance(numbers.curve, ec.SECP256R1):
curve_len = 256
curve_id = CURVE_ID_P256
else:
raise esptool.FatalError("Invalid ECDSA curve instance.")
pubkey_point = _microecc_format(numbers.x, numbers.y, curve_len)
r, s = utils.decode_dss_signature(signature)
signature_rs = _microecc_format(r, s, curve_len)
signature_block = generate_ecdsa_signature_block(
digest, curve_id, pubkey_point, signature_rs
)
signature_block += struct.pack("<I", zlib.crc32(signature_block) & 0xFFFFFFFF)
signature_block += b"\x00" * 16 # padding
if len(signature_block) != SIG_BLOCK_SIZE:
raise esptool.FatalError("Incorrect signature block size")
signature_blocks += signature_block
return signature_blocks
def generate_rsa_signature_block(digest, rsa_primitives, signature):
"""
Encode in rsa signature block format
Note: the [::-1] is to byte swap all of the bignum
values (signatures, coefficients) to little endian
for use with the RSA peripheral, rather than big endian
which is conventionally used for RSA.
"""
signature_block = struct.pack(
"<BBxx32s384sI384sI384s",
SIG_BLOCK_MAGIC,
SIG_BLOCK_VERSION_RSA,
digest,
int_to_bytes(rsa_primitives.n)[::-1],
rsa_primitives.e,
int_to_bytes(rsa_primitives.rinv)[::-1],
rsa_primitives.m & 0xFFFFFFFF,
signature[::-1],
)
return signature_block
def generate_ecdsa_signature_block(digest, curve_id, pubkey_point, signature_rs):
"""
Encode in rsa signature block format
# block is padded out to the much larger size
# of the RSA version of this structure
"""
signature_block = struct.pack(
"<BBxx32sB64s64s1031x",
SIG_BLOCK_MAGIC,
SIG_BLOCK_VERSION_ECDSA,
digest,
curve_id,
pubkey_point,
signature_rs,
)
return signature_block
def verify_signature(args):
if args.version == "1":
return verify_signature_v1(args)
elif args.version == "2":
return verify_signature_v2(args)
def verify_signature_v1(args):
"""Verify a previously signed binary image, using the ECDSA public key"""
key_data = args.keyfile.read()
if b"-BEGIN EC PRIVATE KEY" in key_data:
sk = ecdsa.SigningKey.from_pem(key_data)
vk = sk.get_verifying_key()
elif b"-BEGIN PUBLIC KEY" in key_data:
vk = ecdsa.VerifyingKey.from_pem(key_data)
elif len(key_data) == 64:
vk = ecdsa.VerifyingKey.from_string(key_data, curve=ecdsa.NIST256p)
else:
raise esptool.FatalError(
"Verification key does not appear to be an EC key in PEM format "
"or binary EC public key data. Unsupported"
)
if vk.curve != ecdsa.NIST256p:
raise esptool.FatalError(
"Public key uses incorrect curve. ESP32 Secure Boot only supports "
"NIST256p (openssl calls this curve 'prime256v1"
)
binary_content = args.datafile.read()
data = binary_content[0:-68]
sig_version, signature = struct.unpack("I64s", binary_content[-68:])
if sig_version != 0:
raise esptool.FatalError(
"Signature block has version %d. This version of espsecure "
"only supports version 0." % sig_version
)
print("Verifying %d bytes of data" % len(data))
try:
if vk.verify(signature, data, hashlib.sha256):
print("Signature is valid")
else:
raise esptool.FatalError("Signature is not valid")
except ecdsa.keys.BadSignatureError:
raise esptool.FatalError("Signature is not valid")
def validate_signature_block(image_content, sig_blk_num):
offset = -SECTOR_SIZE + sig_blk_num * SIG_BLOCK_SIZE
sig_blk = image_content[offset : offset + SIG_BLOCK_SIZE]
assert len(sig_blk) == SIG_BLOCK_SIZE
# note: in case of ECDSA key, the exact fields in the middle are wrong
# (but unused here)
magic, version, _, _, _, _, _, _, blk_crc = struct.unpack(
"<BBxx32s384sI384sI384sI16x", sig_blk
)
# The signature block(1216 bytes) consists of the data part(1196 bytes)
# followed by a crc32(4 byte) and a 16 byte pad.
calc_crc = zlib.crc32(sig_blk[:1196])
is_invalid_block = magic != SIG_BLOCK_MAGIC
is_invalid_block |= version not in [SIG_BLOCK_VERSION_RSA, SIG_BLOCK_VERSION_ECDSA]
if is_invalid_block or blk_crc != calc_crc & 0xFFFFFFFF: # Signature block invalid
return None
key_type = "RSA" if version == SIG_BLOCK_VERSION_RSA else "ECDSA"
print(f"Signature block {sig_blk_num} is valid ({key_type}).")
return sig_blk
def verify_signature_v2(args):
"""Verify a previously signed binary image, using the RSA or ECDSA public key"""
keyfile = args.keyfile
if args.hsm:
if args.hsm_config is None:
raise esptool.FatalError(
"Config file is required to extract public key from an external HSM."
)
import espsecure.esp_hsm_sign as hsm
try:
config = hsm.read_hsm_config(args.hsm_config)
except Exception as e:
raise esptool.FatalError(f"Incorrect HSM config file format ({e})")
# get public key from HSM
keyfile = extract_pubkey_from_hsm(config)[0]
vk = _get_sbv2_pub_key(keyfile)
if isinstance(vk, rsa.RSAPublicKey):
SIG_BLOCK_MAX_COUNT = 3
elif isinstance(vk, ec.EllipticCurvePublicKey):
SIG_BLOCK_MAX_COUNT = 1
image_content = args.datafile.read()
if len(image_content) < SECTOR_SIZE or len(image_content) % SECTOR_SIZE != 0:
raise esptool.FatalError(
"Invalid datafile. Data size should be non-zero & a multiple of 4096."
)
digest = digest = hashlib.sha256()
digest.update(image_content[:-SECTOR_SIZE])
digest = digest.digest()
valid = False
for sig_blk_num in range(SIG_BLOCK_MAX_COUNT):
sig_blk = validate_signature_block(image_content, sig_blk_num)
if sig_blk is None:
print(f"Signature block {sig_blk_num} invalid. Skipping.")
continue
_, version, blk_digest = struct.unpack("<BBxx32s", sig_blk[:36])
if blk_digest != digest:
raise esptool.FatalError(
"Signature block image digest does not match "
f"the actual image digest {digest}. Expected {blk_digest}."
)
try:
if isinstance(vk, rsa.RSAPublicKey):
_, _, _, _, signature, _ = struct.unpack(
"<384sI384sI384sI16x", sig_blk[36:]
)
vk.verify(
signature[::-1],
digest,
padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32),
utils.Prehashed(hashes.SHA256()),
)
else:
curve_id, _pubkey, encoded_rs = struct.unpack(
"B64s64s1031x4x16x", sig_blk[36:]
)
assert curve_id in (CURVE_ID_P192, CURVE_ID_P256)
keylen = (
24 if curve_id == CURVE_ID_P192 else 32
) # length of each number in the keypair
r = int.from_bytes(encoded_rs[:keylen], "little")
s = int.from_bytes(encoded_rs[keylen : keylen * 2], "little")
signature = utils.encode_dss_signature(r, s)
vk.verify(signature, digest, ec.ECDSA(utils.Prehashed(hashes.SHA256())))
key_type = "RSA" if isinstance(vk, rsa.RSAPublicKey) else "ECDSA"
print(
f"Signature block {sig_blk_num} verification successful using "
f"the supplied key ({key_type})."
)
valid = True
except exceptions.InvalidSignature:
print(
f"Signature block {sig_blk_num} is not signed by the supplied key. "
"Checking the next block"
)
continue
if not valid:
raise esptool.FatalError(
"Checked all blocks. Signature could not be verified with the provided key."
)
def extract_public_key(args):
_check_output_is_not_input(args.keyfile, args.public_keyfile)
if args.version == "1":
"""
Load an ECDSA private key and extract the embedded public key
as raw binary data.
"""
sk = _load_ecdsa_signing_key(args.keyfile)
vk = sk.get_verifying_key()
args.public_keyfile.write(vk.to_string())
elif args.version == "2":
"""
Load an RSA or an ECDSA private key and extract the public key
as raw binary data.
"""
sk = _load_sbv2_signing_key(args.keyfile.read())
vk = sk.public_key().public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo,
)
args.public_keyfile.write(vk)
print(
"%s public key extracted to %s" % (args.keyfile.name, args.public_keyfile.name)
)
def extract_pubkey_from_hsm(config):
import espsecure.esp_hsm_sign as hsm
session = hsm.establish_session(config)
# get public key from HSM
public_key = hsm.get_pubkey(session, config)
hsm.close_connection(session)
pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo,
)
temp_pub_key_file = tempfile.TemporaryFile()
temp_pub_key_file.write(pem)
temp_pub_key_file.seek(0)
return [temp_pub_key_file]
def _sha256_digest(data):
digest = hashlib.sha256()
digest.update(data)
return digest.digest()
def signature_info_v2(args):
"""
Validates the signature block and prints the RSA/ECDSA public key
digest for valid blocks
"""
SIG_BLOCK_MAX_COUNT = 3
image_content = args.datafile.read()
if len(image_content) < SECTOR_SIZE or len(image_content) % SECTOR_SIZE != 0:
raise esptool.FatalError(
"Invalid datafile. Data size should be non-zero & a multiple of 4096."
)
digest = _sha256_digest(image_content[:-SECTOR_SIZE])
for sig_blk_num in range(SIG_BLOCK_MAX_COUNT):
sig_blk = validate_signature_block(image_content, sig_blk_num)
if sig_blk is None:
print(
"Signature block %d absent/invalid. Skipping checking next blocks."
% sig_blk_num
)
return
sig_data = struct.unpack("<BBxx32s384sI384sI384sI16x", sig_blk)
if sig_data[2] != digest:
raise esptool.FatalError(
"Digest in signature block %d doesn't match the image digest."
% (sig_blk_num)
)
offset = -SECTOR_SIZE + sig_blk_num * SIG_BLOCK_SIZE
sig_blk = image_content[offset : offset + SIG_BLOCK_SIZE]
if sig_data[1] == SIG_BLOCK_VERSION_RSA:
key_digest = _sha256_digest(sig_blk[36:812])
elif sig_data[1] == SIG_BLOCK_VERSION_ECDSA:
key_digest = _sha256_digest(sig_blk[36:101])
else:
raise esptool.FatalError(
"Unsupported scheme in signature block %d" % (sig_blk_num)
)
print(
"Public key digest for block %d: %s"
% (sig_blk_num, " ".join("{:02x}".format(c) for c in bytearray(key_digest)))
)
def _digest_sbv2_public_key(keyfile):
public_key = _get_sbv2_pub_key(keyfile)
if isinstance(public_key, rsa.RSAPublicKey):
rsa_primitives = _get_sbv2_rsa_primitives(public_key)
# Encode in the same way it is represented in the signature block
#
# Note: the [::-1] is to byte swap all of the bignum
# values (signatures, coefficients) to little endian
# for use with the RSA peripheral, rather than big endian
# which is conventionally used for RSA.
binary_format = struct.pack(
"<384sI384sI",
int_to_bytes(rsa_primitives.n)[::-1],
rsa_primitives.e,
int_to_bytes(rsa_primitives.rinv)[::-1],
rsa_primitives.m & 0xFFFFFFFF,
)
else: # ECC public key
numbers = public_key.public_numbers()
if isinstance(public_key.curve, ec.SECP192R1):
curve_len = 192
curve_id = CURVE_ID_P192
else:
curve_len = 256
curve_id = CURVE_ID_P256
pubkey_point = _microecc_format(numbers.x, numbers.y, curve_len)
binary_format = struct.pack(
"<B64s",
curve_id,
pubkey_point,
)
return hashlib.sha256(binary_format).digest()
def digest_sbv2_public_key(args):
_check_output_is_not_input(args.keyfile, args.output)
public_key_digest = _digest_sbv2_public_key(args.keyfile)
with open(args.output, "wb") as f:
print(
"Writing the public key digest of %s to %s."
% (args.keyfile.name, args.output)
)
f.write(public_key_digest)
def digest_rsa_public_key(args):
# Kept for compatibility purpose
digest_sbv2_public_key(args)
def digest_private_key(args):
_check_output_is_not_input(args.keyfile, args.digest_file)
sk = _load_ecdsa_signing_key(args.keyfile)
repr(sk.to_string())
digest = hashlib.sha256()
digest.update(sk.to_string())
result = digest.digest()
if args.keylen == 192:
result = result[0:24]
args.digest_file.write(result)
print(
"SHA-256 digest of private key %s%s written to %s"
% (
args.keyfile.name,
"" if args.keylen == 256 else " (truncated to 192 bits)",
args.digest_file.name,
)
)
# flash encryption key tweaking pattern: the nth bit of the key is
# flipped if the kth bit in the flash offset is set, where mapping
# from n to k is provided by this list of 'n' bit offsets (range k)
# fmt: off
_FLASH_ENCRYPTION_TWEAK_PATTERN = [
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
8, 7, 6, 5
]
assert len(_FLASH_ENCRYPTION_TWEAK_PATTERN) == 256
# fmt: on
def _flash_encryption_tweak_range(flash_crypt_config=0xF):
"""Return a list of the bit indexes that the "key tweak" applies to,
as determined by the FLASH_CRYPT_CONFIG 4 bit efuse value.
"""
tweak_range = []
if (flash_crypt_config & 1) != 0:
tweak_range += range(67)
if (flash_crypt_config & 2) != 0:
tweak_range += range(67, 132)
if (flash_crypt_config & 4) != 0:
tweak_range += range(132, 195)
if (flash_crypt_config & 8) != 0:
tweak_range += range(195, 256)
return tweak_range
def _flash_encryption_tweak_range_bits(flash_crypt_config=0xF):
"""Return bits (in reverse order) that the "key tweak" applies to,
as determined by the FLASH_CRYPT_CONFIG 4 bit efuse value.
"""
tweak_range = 0
if (flash_crypt_config & 1) != 0:
tweak_range |= (
0xFFFFFFFFFFFFFFFFE00000000000000000000000000000000000000000000000
)
if (flash_crypt_config & 2) != 0:
tweak_range |= (
0x00000000000000001FFFFFFFFFFFFFFFF0000000000000000000000000000000
)
if (flash_crypt_config & 4) != 0:
tweak_range |= (
0x000000000000000000000000000000000FFFFFFFFFFFFFFFE000000000000000
)
if (flash_crypt_config & 8) != 0:
tweak_range |= (
0x0000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFF
)
return tweak_range
# Forward bit order masks
mul1 = 0x0000200004000080000004000080001000000200004000080000040000800010
mul2 = 0x0000000000000000200000000000000010000000000000002000000000000001
mul1_mask = 0xFFFFFFFFFFFFFF801FFFFFFFFFFFFFF00FFFFFFFFFFFFFF81FFFFFFFFFFFFFF0
mul2_mask = 0x000000000000007FE00000000000000FF000000000000007E00000000000000F
def _flash_encryption_tweak_key(key, offset, tweak_range):
"""Apply XOR "tweak" values to the key, derived from flash offset
'offset'. This matches the ESP32 hardware flash encryption.
tweak_range is a list of bit indexes to apply the tweak to, as
generated by _flash_encryption_tweak_range() from the
FLASH_CRYPT_CONFIG efuse value.
Return tweaked key
"""
addr = offset >> 5
key ^= ((mul1 * addr) | ((mul2 * addr) & mul2_mask)) & tweak_range
return int.to_bytes(key, length=32, byteorder="big", signed=False)
def generate_flash_encryption_key(args):
print("Writing %d random bits to key file %s" % (args.keylen, args.key_file.name))
args.key_file.write(os.urandom(args.keylen // 8))
def _flash_encryption_operation_esp32(
output_file, input_file, flash_address, keyfile, flash_crypt_conf, do_decrypt
):
key = _load_hardware_key(keyfile)
if flash_address % 16 != 0:
raise esptool.FatalError(
"Starting flash address 0x%x must be a multiple of 16" % flash_address
)
if flash_crypt_conf == 0:
print("WARNING: Setting FLASH_CRYPT_CONF to zero is not recommended")
tweak_range = _flash_encryption_tweak_range_bits(flash_crypt_conf)
key = int.from_bytes(key, byteorder="big", signed=False)
backend = default_backend()
cipher = None
block_offs = flash_address
while True:
block = input_file.read(16)
if len(block) == 0:
break
elif len(block) < 16:
if do_decrypt:
raise esptool.FatalError("Data length is not a multiple of 16 bytes")
pad = 16 - len(block)
block = block + os.urandom(pad)
print(
"Note: Padding with %d bytes of random data "
"(encrypted data must be multiple of 16 bytes long)" % pad
)
if block_offs % 32 == 0 or cipher is None:
# each bit of the flash encryption key is XORed with tweak bits
# derived from the offset of 32 byte block of flash
block_key = _flash_encryption_tweak_key(key, block_offs, tweak_range)
if cipher is None: # first pass
cipher = Cipher(algorithms.AES(block_key), modes.ECB(), backend=backend)
# note AES is used inverted for flash encryption, so
# "decrypting" flash uses AES encrypt algorithm and vice
# versa. (This does not weaken AES.)
actor = cipher.encryptor() if do_decrypt else cipher.decryptor()
else:
# performance hack: changing the key using pyca-cryptography API
# requires recreating'actor'.
# With openssl backend, this re-initializes the openssl cipher context.
# To save some time, manually call EVP_CipherInit_ex() in the openssl
# backend to update the key.
# If it fails, fall back to recreating the entire context via public API
try:
backend = actor._ctx._backend
res = backend._lib.EVP_CipherInit_ex(
actor._ctx._ctx,
backend._ffi.NULL,
backend._ffi.NULL,
backend._ffi.from_buffer(block_key),
backend._ffi.NULL,
actor._ctx._operation,
)
backend.openssl_assert(res != 0)
except AttributeError:
# backend is not an openssl backend, or implementation has changed:
# fall back to the slow safe version
cipher.algorithm.key = block_key
actor = cipher.encryptor() if do_decrypt else cipher.decryptor()
block = block[::-1] # reverse input block byte order
block = actor.update(block)
output_file.write(block[::-1]) # reverse output block byte order
block_offs += 16
def _flash_encryption_operation_aes_xts(
output_file, input_file, flash_address, keyfile, do_decrypt
):
"""
Apply the AES-XTS algorithm with the hardware addressing scheme used by Espressif
key = AES-XTS key (32 or 64 bytes)
flash_address = address in flash to encrypt at. Must be multiple of 16 bytes.
indata = Data to encrypt/decrypt. Must be multiple of 16 bytes.
encrypt = True to Encrypt indata, False to decrypt indata.
Returns a bitstring of the ciphertext or plaintext result.
"""
backend = default_backend()
key = _load_hardware_key(keyfile)
indata = input_file.read()
if flash_address % 16 != 0:
raise esptool.FatalError(
"Starting flash address 0x%x must be a multiple of 16" % flash_address
)
if len(indata) % 16 != 0:
raise esptool.FatalError(
"Input data length (%d) must be a multiple of 16" % len(indata)
)
if len(indata) == 0:
raise esptool.FatalError("Input data must be longer than 0")
# left pad for a 1024-bit aligned address
pad_left = flash_address % 0x80
indata = (b"\x00" * pad_left) + indata
# right pad for full 1024-bit blocks
pad_right = len(indata) % 0x80
if pad_right > 0:
pad_right = 0x80 - pad_right
indata = indata + (b"\x00" * pad_right)
inblocks = _split_blocks(indata, 0x80) # split into 1024 bit blocks
output = []
for inblock in inblocks: # for each block
tweak = struct.pack("<I", (flash_address & ~0x7F)) + (b"\x00" * 12)
flash_address += 0x80 # for next block
if len(tweak) != 16:
raise esptool.FatalError(
"Length of tweak must be 16, was {}".format(len(tweak))
)
cipher = Cipher(algorithms.AES(key), modes.XTS(tweak), backend=backend)
encryptor = cipher.decryptor() if do_decrypt else cipher.encryptor()
inblock = inblock[::-1] # reverse input
outblock = encryptor.update(inblock) # standard algo
output.append(outblock[::-1]) # reverse output
output = b"".join(output)
# undo any padding we applied to the input
if pad_right != 0:
output = output[:-pad_right]
if pad_left != 0:
output = output[pad_left:]
# output length matches original input
if len(output) != len(indata) - pad_left - pad_right:
raise esptool.FatalError(
"Length of input data ({}) should match the output data ({})".format(
len(indata) - pad_left - pad_right, len(output)
)
)
output_file.write(output)
def _split_blocks(text, block_len=16):
"""Take a bitstring, split it into chunks of "block_len" each"""
assert len(text) % block_len == 0
pos = 0
while pos < len(text):
yield text[pos : pos + block_len]
pos = pos + block_len
def decrypt_flash_data(args):
_check_output_is_not_input(args.keyfile, args.output)
_check_output_is_not_input(args.encrypted_file, args.output)
if args.aes_xts:
return _flash_encryption_operation_aes_xts(
args.output, args.encrypted_file, args.address, args.keyfile, True
)
else:
return _flash_encryption_operation_esp32(
args.output,
args.encrypted_file,
args.address,
args.keyfile,
args.flash_crypt_conf,
True,
)
def encrypt_flash_data(args):
_check_output_is_not_input(args.keyfile, args.output)
_check_output_is_not_input(args.plaintext_file, args.output)
if args.aes_xts:
return _flash_encryption_operation_aes_xts(
args.output, args.plaintext_file, args.address, args.keyfile, False
)
else:
return _flash_encryption_operation_esp32(
args.output,
args.plaintext_file,
args.address,
args.keyfile,
args.flash_crypt_conf,
False,
)
def _samefile(p1, p2):
return os.path.normcase(os.path.normpath(p1)) == os.path.normcase(
os.path.normpath(p2)
)
def _check_output_is_not_input(input_file, output_file):
i = getattr(input_file, "name", input_file)
o = getattr(output_file, "name", output_file)
# i & o should be string containing the path to files if espsecure
# was invoked from command line
# i & o still can be something else when espsecure was imported
# and the functions used directly (e.g. io.BytesIO())
check_f = _samefile if isinstance(i, str) and isinstance(o, str) else operator.eq
if check_f(i, o):
raise esptool.FatalError(
'The input "{}" and output "{}" should not be the same!'.format(i, o)
)
class OutFileType(object):
"""
This class is a replacement of argparse.FileType('wb').
It doesn't create a file immediately but only during thefirst write.
This allows us to do some checking before,
e.g. that we are not overwriting the input.
argparse.FileType('w')('-') returns STDOUT but argparse.FileType('wb') is not.
The file object is not closed on failure
just like in the case of argparse.FileType('w').
"""
def __init__(self):
self.path = None
self.file_obj = None
def __call__(self, path):
self.path = path
return self
def __repr__(self):
return "{}({})".format(type(self).__name__, self.path)
def write(self, payload):
if len(payload) > 0:
if not self.file_obj:
self.file_obj = open(self.path, "wb")
self.file_obj.write(payload)
def close(self):
if self.file_obj:
self.file_obj.close()
self.file_obj = None
@property
def name(self):
return self.path
def main(custom_commandline=None):
"""
Main function for espsecure
custom_commandline - Optional override for default arguments parsing
(that uses sys.argv), can be a list of custom arguments as strings.
Arguments and their values need to be added as individual items to the list
e.g. "--port /dev/ttyUSB1" thus becomes ['--port', '/dev/ttyUSB1'].
"""
parser = argparse.ArgumentParser(
description="espsecure.py v%s - ESP32 Secure Boot & Flash Encryption tool"
% esptool.__version__,
prog="espsecure",
)
subparsers = parser.add_subparsers(
dest="operation", help="Run espsecure.py {command} -h for additional help"
)
p = subparsers.add_parser(
"digest_secure_bootloader",
help="Take a bootloader binary image and a secure boot key, "
"and output a combined digest+binary suitable for flashing along "
"with the precalculated secure boot key.",
)
p.add_argument(
"--keyfile",
"-k",
help="256 bit key for secure boot digest.",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument("--output", "-o", help="Output file for signed digest image.")
p.add_argument(
"--iv",
help="128 byte IV file. Supply a file for testing purposes only, "
"if not supplied an IV will be randomly generated.",
type=argparse.FileType("rb"),
)
p.add_argument(
"image",
help="Bootloader image file to calculate digest from",
type=argparse.FileType("rb"),
)
p = subparsers.add_parser(
"generate_signing_key",
help="Generate a private key for signing secure boot images "
"as per the secure boot version. "
"Key file is generated in PEM format, "
"Secure Boot V1 - ECDSA NIST256p private key. "
"Secure Boot V2 - RSA 3072, ECDSA NIST256p, ECDSA NIST192p private key.",
)
p.add_argument(
"--version",
"-v",
help="Version of the secure boot signing scheme to use.",
choices=["1", "2"],
default="1",
)
p.add_argument(
"--scheme",
"-s",
help="Scheme of secure boot signing.",
choices=["rsa3072", "ecdsa192", "ecdsa256"],
required=False,
)
p.add_argument(
"keyfile", help="Filename for private key file (embedded public key)"
)
p = subparsers.add_parser(
"sign_data",
help="Sign a data file for use with secure boot. "
"Signing algorithm is deterministic ECDSA w/ SHA-512 (V1) "
"or either RSA-PSS or ECDSA w/ SHA-256 (V2).",
)
p.add_argument(
"--version",
"-v",
help="Version of the secure boot signing scheme to use.",
choices=["1", "2"],
required=True,
)
p.add_argument(
"--keyfile",
"-k",
help="Private key file for signing. Key is in PEM format.",
type=argparse.FileType("rb"),
nargs="+",
)
p.add_argument(
"--append_signatures",
"-a",
help="Append signature block(s) to already signed image. "
"Valid only for ESP32-S2.",
action="store_true",
)
p.add_argument(
"--hsm",
help="Use an external Hardware Security Module "
"to generate signature using PKCS#11 interface.",
action="store_true",
)
p.add_argument(
"--hsm-config",
help="Config file for the external Hardware Security Module "
"to be used to generate signature.",
default=None,
)
p.add_argument(
"--pub-key",
help="Public key files corresponding to the private key used to generate "
"the pre-calculated signatures. Keys should be in PEM format.",
type=argparse.FileType("rb"),
nargs="+",
)
p.add_argument(
"--signature",
help="Pre-calculated signatures. "
"Signatures generated using external private keys e.g. keys stored in HSM.",
type=argparse.FileType("rb"),
nargs="+",
default=None,
)
p.add_argument(
"--output",
"-o",
help="Output file for signed digest image. Default is to sign the input file.",
)
p.add_argument(
"datafile",
help="File to sign. For version 1, this can be any file. "
"For version 2, this must be a valid app image.",
type=argparse.FileType("rb"),
)
p = subparsers.add_parser(
"verify_signature",
help='Verify a data file previously signed by "sign_data", '
"using the public key.",
)
p.add_argument(
"--version",
"-v",
help="Version of the secure boot scheme to use.",
choices=["1", "2"],
required=True,
)
p.add_argument(
"--hsm",
help="Use an external Hardware Security Module "
"to verify signature using PKCS#11 interface.",
action="store_true",
)
p.add_argument(
"--hsm-config",
help="Config file for the external Hardware Security Module "
"to be used to verify signature.",
default=None,
)
p.add_argument(
"--keyfile",
"-k",
help="Public key file for verification. "
"Can be private or public key in PEM format.",
type=argparse.FileType("rb"),
)
p.add_argument(
"datafile",
help="Signed data file to verify signature.",
type=argparse.FileType("rb"),
)
p = subparsers.add_parser(
"extract_public_key",
help="Extract the public verification key for signatures, "
"save it as a raw binary file.",
)
p.add_argument(
"--version",
"-v",
help="Version of the secure boot signing scheme to use.",
choices=["1", "2"],
default="1",
)
p.add_argument(
"--keyfile",
"-k",
help="Private key file (PEM format) to extract the "
"public verification key from.",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument(
"public_keyfile", help="File to save new public key into", type=OutFileType()
)
# Kept for compatibility purpose. We can deprecate this in a future release
p = subparsers.add_parser(
"digest_rsa_public_key",
help="Generate an SHA-256 digest of the RSA public key. "
"This digest is burned into the eFuse and asserts the legitimacy "
"of the public key for Secure boot v2.",
)
p.add_argument(
"--keyfile",
"-k",
help="Public key file for verification. "
"Can be private or public key in PEM format.",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument("--output", "-o", help="Output file for the digest.", required=True)
p = subparsers.add_parser(
"digest_sbv2_public_key",
help="Generate an SHA-256 digest of the public key. "
"This digest is burned into the eFuse and asserts the legitimacy "
"of the public key for Secure boot v2.",
)
p.add_argument(
"--keyfile",
"-k",
help="Public key file for verification. "
"Can be private or public key in PEM format.",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument("--output", "-o", help="Output file for the digest.", required=True)
p = subparsers.add_parser(
"signature_info_v2",
help="Reads the signature block and provides the signature block information.",
)
p.add_argument(
"datafile",
help="Secure boot v2 signed data file.",
type=argparse.FileType("rb"),
)
p = subparsers.add_parser(
"digest_private_key",
help="Generate an SHA-256 digest of the private signing key. "
"This can be used as a reproducible secure bootloader (only secure boot v1) "
"or flash encryption key.",
)
p.add_argument(
"--keyfile",
"-k",
help="Private key file (PEM format) to generate a digest from.",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument(
"--keylen",
"-l",
help="Length of private key digest file to generate (in bits). "
"3/4 Coding Scheme requires 192 bit key.",
choices=[192, 256],
default=256,
type=int,
)
p.add_argument(
"digest_file", help="File to write 32 byte digest into", type=OutFileType()
)
p = subparsers.add_parser(
"generate_flash_encryption_key",
help="Generate a development-use flash encryption key with random data.",
)
p.add_argument(
"--keylen",
"-l",
help="Length of private key digest file to generate (in bits). "
"3/4 Coding Scheme requires 192 bit key.",
choices=[128, 192, 256, 512],
default=256,
type=int,
)
p.add_argument(
"key_file",
help="File to write 16, 24, 32 or 64 byte key into",
type=OutFileType(),
)
p = subparsers.add_parser(
"decrypt_flash_data",
help="Decrypt some data read from encrypted flash (using known key)",
)
p.add_argument(
"encrypted_file",
help="File with encrypted flash contents",
type=argparse.FileType("rb"),
)
p.add_argument(
"--aes_xts",
"-x",
help="Decrypt data using AES-XTS as used on "
"ESP32-S2, ESP32-C2, ESP32-C3 and ESP32-C6",
action="store_true",
)
p.add_argument(
"--keyfile",
"-k",
help="File with flash encryption key",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument(
"--output",
"-o",
help="Output file for plaintext data.",
type=OutFileType(),
required=True,
)
p.add_argument(
"--address",
"-a",
help="Address offset in flash that file was read from.",
required=True,
type=esptool.arg_auto_int,
)
p.add_argument(
"--flash_crypt_conf",
help="Override FLASH_CRYPT_CONF efuse value (default is 0XF).",
required=False,
default=0xF,
type=esptool.arg_auto_int,
)
p = subparsers.add_parser(
"encrypt_flash_data",
help="Encrypt some data suitable for encrypted flash (using known key)",
)
p.add_argument(
"--aes_xts",
"-x",
help="Encrypt data using AES-XTS as used on "
"ESP32-S2, ESP32-C2, ESP32-C3 and ESP32-C6",
action="store_true",
)
p.add_argument(
"--keyfile",
"-k",
help="File with flash encryption key",
type=argparse.FileType("rb"),
required=True,
)
p.add_argument(
"--output",
"-o",
help="Output file for encrypted data.",
type=OutFileType(),
required=True,
)
p.add_argument(
"--address",
"-a",
help="Address offset in flash where file will be flashed.",
required=True,
type=esptool.arg_auto_int,
)
p.add_argument(
"--flash_crypt_conf",
help="Override FLASH_CRYPT_CONF efuse value (default is 0XF).",
required=False,
default=0xF,
type=esptool.arg_auto_int,
)
p.add_argument(
"plaintext_file",
help="File with plaintext content for encrypting",
type=argparse.FileType("rb"),
)
args = parser.parse_args(custom_commandline)
print("espsecure.py v%s" % esptool.__version__)
if args.operation is None:
parser.print_help()
parser.exit(1)
try:
# each 'operation' is a module-level function of the same name
operation_func = globals()[args.operation]
operation_func(args)
finally:
for arg_name in vars(args):
obj = getattr(args, arg_name)
if isinstance(obj, OutFileType):
obj.close()
def _main():
try:
main()
except esptool.FatalError as e:
print("\nA fatal error occurred: %s" % e)
sys.exit(2)
except ValueError as e:
try:
if [arg for arg in e.args if "Could not deserialize key data." in arg]:
print(
"Note: This error originates from the cryptography module. "
"It is likely not a problem with espsecure, "
"please make sure you are using a compatible OpenSSL backend."
)
finally:
raise
if __name__ == "__main__":
_main()
| 63,263 | Python | .py | 1,573 | 31.539097 | 88 | 0.612827 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,594 | __init__.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espsecure/esp_hsm_sign/__init__.py | # SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import binascii
import configparser
import os
import sys
from getpass import getpass
try:
import pkcs11
from .exceptions import handle_exceptions
except ImportError:
raise ImportError(
"python-pkcs11 package is not installed. "
"Please install it using the required packages with command: "
"pip install 'esptool[hsm]'"
)
import cryptography.hazmat.primitives.asymmetric.ec as EC
import cryptography.hazmat.primitives.asymmetric.rsa as RSA
import ecdsa
def read_hsm_config(configfile):
config = configparser.ConfigParser()
config.read(configfile)
section = "hsm_config"
if not config.has_section(section):
raise configparser.NoSectionError(section)
section_options = ["pkcs11_lib", "slot", "label"]
for option in section_options:
if not config.has_option(section, option):
raise configparser.NoOptionError(option, section)
# If the config file does not contain the "credentials" option,
# prompt the user for the HSM PIN
if not config.has_option(section, "credentials"):
hsm_pin = getpass("Please enter the PIN of your HSM:\n")
config.set(section, "credentials", hsm_pin)
return config[section]
def establish_session(config):
print("Trying to establish a session with the HSM.")
try:
if os.path.exists(config["pkcs11_lib"]):
lib = pkcs11.lib(config["pkcs11_lib"])
else:
print(f'LIB file does not exist at {config["pkcs11_lib"]}')
sys.exit(1)
for slot in lib.get_slots(token_present=True):
if slot.slot_id == int(config["slot"]):
break
token = slot.get_token()
session = token.open(rw=True, user_pin=config["credentials"])
print(f'Session creation successful with HSM slot {int(config["slot"])}.')
return session
except pkcs11.exceptions.PKCS11Error as e:
handle_exceptions(e)
print("Session establishment failed")
sys.exit(1)
def get_privkey_info(session, config):
try:
private_key = session.get_key(
object_class=pkcs11.constants.ObjectClass.PRIVATE_KEY, label=config["label"]
)
print(f'Got private key metadata with label {config["label"]}.')
return private_key
except pkcs11.exceptions.PKCS11Error as e:
handle_exceptions(e)
print("Failed to get the private key")
sys.exit(1)
def get_pubkey(session, config):
print("Trying to extract public key from the HSM.")
try:
if "label_pubkey" in config:
public_key_label = config["label_pubkey"]
else:
print(
"Config option 'label_pubkey' not found, "
"using config option 'label' for public key."
)
public_key_label = config["label"]
public_key = session.get_key(
object_class=pkcs11.constants.ObjectClass.PUBLIC_KEY,
label=public_key_label,
)
if public_key.key_type == pkcs11.mechanisms.KeyType.RSA:
exponent = public_key[pkcs11.Attribute.PUBLIC_EXPONENT]
modulus = public_key[pkcs11.Attribute.MODULUS]
e = int.from_bytes(exponent, byteorder="big")
n = int.from_bytes(modulus, byteorder="big")
public_key = RSA.RSAPublicNumbers(e, n).public_key()
elif public_key.key_type == pkcs11.mechanisms.KeyType.EC:
ecpoints, _ = ecdsa.der.remove_octet_string(
public_key[pkcs11.Attribute.EC_POINT]
)
public_key = EC.EllipticCurvePublicKey.from_encoded_point(
EC.SECP256R1(), ecpoints
)
else:
print("Incorrect public key algorithm")
sys.exit(1)
print(f"Got public key with label {public_key_label}.")
return public_key
except pkcs11.exceptions.PKCS11Error as e:
handle_exceptions(e)
print("Failed to extract the public key")
sys.exit(1)
def sign_payload(private_key, payload):
try:
print("Signing payload using the HSM.")
key_type = private_key.key_type
mechanism, mechanism_params = get_mechanism(key_type)
signature = private_key.sign(
data=payload, mechanism=mechanism, mechanism_param=mechanism_params
)
if len(signature) != 0:
print("Signature generation successful.")
if key_type == pkcs11.mechanisms.KeyType.EC:
r = int(binascii.hexlify(signature[:32]), 16)
s = int(binascii.hexlify(signature[32:]), 16)
# der encoding in case of ecdsa signatures
signature = ecdsa.der.encode_sequence(
ecdsa.der.encode_integer(r), ecdsa.der.encode_integer(s)
)
return signature
except pkcs11.exceptions.PKCS11Error as e:
handle_exceptions(e, mechanism)
print("Payload Signing Failed")
sys.exit(1)
def get_mechanism(key_type):
if key_type == pkcs11.mechanisms.KeyType.RSA:
return pkcs11.mechanisms.Mechanism.SHA256_RSA_PKCS_PSS, (
pkcs11.mechanisms.Mechanism.SHA256,
pkcs11.MGF.SHA256,
32,
)
elif key_type == pkcs11.mechanisms.KeyType.EC:
return pkcs11.mechanisms.Mechanism.ECDSA_SHA256, None
else:
print("Invalid signing key mechanism")
sys.exit(1)
def close_connection(session):
try:
session.close()
print("Connection closed successfully")
except pkcs11.exceptions.PKCS11Error as e:
handle_exceptions(e)
print("Failed to close the HSM session")
sys.exit(1)
| 5,796 | Python | .py | 145 | 31.393103 | 88 | 0.644765 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,595 | exceptions.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/espsecure/esp_hsm_sign/exceptions.py | # SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
from pkcs11.exceptions import (
AlreadyInitialized,
AnotherUserAlreadyLoggedIn,
ArgumentsBad,
DeviceRemoved,
DomainParamsInvalid,
FunctionFailed,
MechanismInvalid,
NoSuchKey,
NoSuchToken,
OperationNotInitialized,
SessionClosed,
)
def handle_exceptions(e, info=""):
exception_type = e.__class__
if exception_type == MechanismInvalid:
print("The External HSM does not support the given mechanism", info)
elif exception_type == FunctionFailed:
print(
"Please ensure proper configuration, privileges and environment variables"
)
elif exception_type == AlreadyInitialized:
print("pkcs11 is already initialized with another library")
elif exception_type == AnotherUserAlreadyLoggedIn:
print("Another User has been already logged in")
elif exception_type == ArgumentsBad:
print("Please check the arguments supplied to the function")
elif exception_type == DomainParamsInvalid:
print("Invalid or unsupported domain parameters were supplied to the function")
elif exception_type == DeviceRemoved:
print(
"The token has been removed from its slot during "
"the execution of the function"
)
elif exception_type == NoSuchToken:
print("No such token found")
elif exception_type == NoSuchKey:
print("No such key found")
elif exception_type == OperationNotInitialized:
print("Operation not Initialized")
elif exception_type == SessionClosed:
print("Session already closed")
else:
print(e.__class__, info)
| 1,750 | Python | .py | 47 | 30.978723 | 87 | 0.702941 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,596 | conf_common.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/docs/conf_common.py | from esp_docs.conf_docs import * # noqa: F403,F401
languages = ["en"]
idf_targets = [
"esp8266",
"esp32",
"esp32s2",
"esp32s3",
"esp32c3",
"esp32c2",
"esp32c6",
"esp32h2",
]
# link roles config
github_repo = "espressif/esptool"
# context used by sphinx_idf_theme
html_context["github_user"] = "espressif"
html_context["github_repo"] = "esptool"
html_static_path = ["../_static"]
# Conditional content
extensions += ["esp_docs.esp_extensions.dummy_build_system"]
ESP8266_DOCS = []
ESP32_DOCS = [
"espefuse/*",
"espsecure/*",
]
ESP32S2_DOCS = ESP32_DOCS
ESP32C3_DOCS = ESP32S2_DOCS
ESP32S3_DOCS = ESP32S2_DOCS
ESP32C2_DOCS = ESP32S3_DOCS
ESP32C6_DOCS = ESP32C2_DOCS
ESP32H2_DOCS = ESP32C6_DOCS
conditional_include_dict = {
"esp8266": ESP8266_DOCS,
"esp32": ESP32_DOCS,
"esp32s2": ESP32S2_DOCS,
"esp32c3": ESP32C3_DOCS,
"esp32s3": ESP32S3_DOCS,
"esp32c2": ESP32C2_DOCS,
"esp32c6": ESP32C6_DOCS,
"esp32h2": ESP32H2_DOCS,
}
# Extra options required by sphinx_idf_theme
project_slug = "esptool"
versions_url = "./_static/esptool_versions.js"
| 1,125 | Python | .py | 44 | 22.568182 | 60 | 0.693897 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,597 | conf.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/docs/en/conf.py | # -*- coding: utf-8 -*-
#
# English Language RTD & Sphinx config file
#
# Uses ../conf_common.py for most non-language-specific settings.
# Importing conf_common adds all the non-language-specific
# parts to this conf module
import datetime
try:
from conf_common import * # noqa: F403,F401
except ImportError:
import os
import sys
sys.path.insert(0, os.path.abspath("../"))
from conf_common import * # noqa: F403,F401
# General information about the project.
project = "esptool.py"
copyright = "2016 - {}, Espressif Systems (Shanghai) Co., Ltd".format(
datetime.datetime.now().year
)
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
language = "en"
| 744 | Python | .py | 23 | 30.043478 | 74 | 0.734266 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,598 | patch_dev_release.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/ci/patch_dev_release.py | # SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: GPL-2.0-or-later
import argparse
import re
LINE_RE = re.compile(r"^__version__ = ['\"]([^'\"]*)['\"]")
NEW_LINE = '__version__ = "{}"'
def get_new_version(old_version, dev_number):
assert old_version.endswith("-dev")
return old_version.replace("-dev", ".dev{}".format(dev_number), 1)
def patch_file(path, dev_number):
with open(path, "r") as fin:
lines = fin.readlines()
for i, line in enumerate(lines, start=0):
m = LINE_RE.search(line)
if m:
old_version = m.group(1)
lines[i] = NEW_LINE.format(get_new_version(old_version, dev_number))
break
with open(path, "w") as fout:
fout.writelines(lines)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("file", help="Path to script with __version__")
parser.add_argument(
"--dev-no", type=int, help="Number N to patch the version to '.devN'"
)
args = parser.parse_args()
patch_file(args.file, args.dev_no)
if __name__ == "__main__":
main()
| 1,133 | Python | .py | 31 | 31.16129 | 80 | 0.622936 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
2,289,599 | reset.py | OLIMEX_RVPC/SOFTWARE/rvpc/esptool/esptool/reset.py | # SPDX-FileCopyrightText: 2014-2023 Fredrik Ahlberg, Angus Gratton,
# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import struct
import time
from .util import FatalError
# Used for resetting into bootloader on Unix-like systems
if os.name != "nt":
import fcntl
import termios
# Constants used for terminal status lines reading/setting.
# Taken from pySerial's backend for IO:
# https://github.com/pyserial/pyserial/blob/master/serial/serialposix.py
TIOCMSET = getattr(termios, "TIOCMSET", 0x5418)
TIOCMGET = getattr(termios, "TIOCMGET", 0x5415)
TIOCM_DTR = getattr(termios, "TIOCM_DTR", 0x002)
TIOCM_RTS = getattr(termios, "TIOCM_RTS", 0x004)
DEFAULT_RESET_DELAY = 0.05 # default time to wait before releasing boot pin after reset
class ResetStrategy(object):
def __init__(self, port, reset_delay=DEFAULT_RESET_DELAY):
self.port = port
self.reset_delay = reset_delay
def __call__():
pass
def _setDTR(self, state):
self.port.setDTR(state)
def _setRTS(self, state):
self.port.setRTS(state)
# Work-around for adapters on Windows using the usbser.sys driver:
# generate a dummy change to DTR so that the set-control-line-state
# request is sent with the updated RTS state and the same DTR state
self.port.setDTR(self.port.dtr)
def _setDTRandRTS(self, dtr=False, rts=False):
status = struct.unpack(
"I", fcntl.ioctl(self.port.fileno(), TIOCMGET, struct.pack("I", 0))
)[0]
if dtr:
status |= TIOCM_DTR
else:
status &= ~TIOCM_DTR
if rts:
status |= TIOCM_RTS
else:
status &= ~TIOCM_RTS
fcntl.ioctl(self.port.fileno(), TIOCMSET, struct.pack("I", status))
class ClassicReset(ResetStrategy):
"""
Classic reset sequence, sets DTR and RTS lines sequentially.
"""
def __call__(self):
self._setDTR(False) # IO0=HIGH
self._setRTS(True) # EN=LOW, chip in reset
time.sleep(0.1)
self._setDTR(True) # IO0=LOW
self._setRTS(False) # EN=HIGH, chip out of reset
time.sleep(self.reset_delay)
self._setDTR(False) # IO0=HIGH, done
class UnixTightReset(ResetStrategy):
"""
UNIX-only reset sequence with custom implementation,
which allows setting DTR and RTS lines at the same time.
"""
def __call__(self):
self._setDTRandRTS(False, False)
self._setDTRandRTS(True, True)
self._setDTRandRTS(False, True) # IO0=HIGH & EN=LOW, chip in reset
time.sleep(0.1)
self._setDTRandRTS(True, False) # IO0=LOW & EN=HIGH, chip out of reset
time.sleep(self.reset_delay)
self._setDTRandRTS(False, False) # IO0=HIGH, done
self._setDTR(False) # Needed in some environments to ensure IO0=HIGH
class USBJTAGSerialReset(ResetStrategy):
"""
Custom reset sequence, which is required when the device
is connecting via its USB-JTAG-Serial peripheral.
"""
def __call__(self):
self._setRTS(False)
self._setDTR(False) # Idle
time.sleep(0.1)
self._setDTR(True) # Set IO0
self._setRTS(False)
time.sleep(0.1)
self._setRTS(True) # Reset. Calls inverted to go through (1,1) instead of (0,0)
self._setDTR(False)
self._setRTS(True) # RTS set as Windows only propagates DTR on RTS setting
time.sleep(0.1)
self._setDTR(False)
self._setRTS(False) # Chip out of reset
class HardReset(ResetStrategy):
"""
Reset sequence for hard resetting the chip.
Can be used to reset out of the bootloader or to restart a running app.
"""
def __init__(self, port, uses_usb_otg=False):
super().__init__(port)
self.uses_usb_otg = uses_usb_otg
def __call__(self):
self._setRTS(True) # EN->LOW
if self.uses_usb_otg:
# Give the chip some time to come out of reset,
# to be able to handle further DTR/RTS transitions
time.sleep(0.2)
self._setRTS(False)
time.sleep(0.2)
else:
time.sleep(0.1)
self._setRTS(False)
class CustomReset(ResetStrategy):
"""
Custom reset strategy defined with a string.
CustomReset object is created as "rst = CustomReset(port, seq_str)"
and can be later executed simply with "rst()"
The seq_str input string consists of individual commands divided by "|".
Commands (e.g. R0) are defined by a code (R) and an argument (0).
The commands are:
D: setDTR - 1=True / 0=False
R: setRTS - 1=True / 0=False
U: setDTRandRTS (Unix-only) - 0,0 / 0,1 / 1,0 / or 1,1
W: Wait (time delay) - positive float number
e.g.
"D0|R1|W0.1|D1|R0|W0.05|D0" represents the ClassicReset strategy
"U1,1|U0,1|W0.1|U1,0|W0.05|U0,0" represents the UnixTightReset strategy
"""
format_dict = {
"D": "self.port.setDTR({})",
"R": "self.port.setRTS({})",
"W": "time.sleep({})",
"U": "self._setDTRandRTS({})",
}
def __call__(self):
exec(self.constructed_strategy)
def __init__(self, port, seq_str):
super().__init__(port)
self.constructed_strategy = self._parse_string_to_seq(seq_str)
def _parse_string_to_seq(self, seq_str):
try:
cmds = seq_str.split("|")
fn_calls_list = [self.format_dict[cmd[0]].format(cmd[1:]) for cmd in cmds]
except Exception as e:
raise FatalError(f'Invalid "custom_reset_sequence" option format: {e}')
return "\n".join(fn_calls_list)
| 5,743 | Python | .py | 144 | 32.673611 | 88 | 0.632704 | OLIMEX/RVPC | 8 | 2 | 1 | GPL-3.0 | 9/5/2024, 10:48:43 PM (Europe/Amsterdam) |
Subsets and Splits