def run_yolo_inference(config: argparse.Namespace):
# set the device for inference
device = "cuda"
weight_path = "/Users/loki/Datasets/pretrained_models/bdd_epoch_100.pt"
# load model
model = load_yolov3_model(weight_path, device, checkpoint=True)
img_size = 416
dataloader = load_dataset(type_="coco",
img_dir="/Users/loki/Datasets/BerkleyBAIR/bdd100k/images/100k/val",
label_file="/Users/loki/Datasets/BerkleyBAIR/bdd100k/labels/bdd100k_labels_images_val.json.coco_format.json",
img_size=img_size,
batch_size=16,
n_cpu=32,
shuffle=False,
augment=False)
# run detection
model = model.to(device)
print(device)
print(img_size)
results = run_detection(model, dataloader, device, img_size=img_size)
print("result:", results)
def run_yolo_inference(config: argparse.Namespace):
# region logging
current_datetime_str = datetime.datetime.now().strftime(
"%Y-%m-%d-%H-%M-%S")
log_file_name_by_time = current_datetime_str + ".log"
if config.debug:
log_level = logging.DEBUG
elif config.verbose:
log_level = logging.INFO
else:
log_level = logging.WARNING
config_logging(config.log_dir, log_file_name_by_time, level=log_level)
# endregion
# set the device for inference
device = config_device(config.cpu_only)
make_output_dir(config.out_dir)
# load model
model = load_yolov3_model(config.weight_path,
device,
checkpoint=config.from_ckpt)
#config.label_path
# load data
dataloader = load_dataset(type_=config.dataset_type,
img_dir=config.img_dir,
label_file=None,
img_size=config.img_size,
batch_size=config.batch_size,
n_cpu=config.n_cpu,
shuffle=False,
augment=False)
# run detection
model = model.to(device)
results = run_detection(model, dataloader, device, config.conf_thres,
config.nms_thres)
# post processing
if config.save_det:
json_path = '{}/{}/detections.json'.format(config.out_dir,
current_datetime_str)
make_output_dir(os.path.split(json_path)[0])
save_results_as_json(results, json_path)
if config.save_img:
class_names = load_class_names_from_file(config.class_path)
img_path = '{}/{}/img'.format(config.out_dir, current_datetime_str)
make_output_dir(img_path)
save_results_as_images(results, img_path, class_names)
return
def run_yolo_evaluation(config: argparse.Namespace):
# region logging
# current_datetime_str = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
# log_file_name_by_time = current_datetime_str + ".log"
# if config.debug:
# log_level = logging.DEBUG
# elif config.verbose:
# log_level = logging.INFO
# else:
# log_level = logging.WARNING
# config_logging(config.log_dir, log_file_name_by_time, level=log_level)
# endregion
# set the device for inference
device = config_device(config.cpu_only)
# load model
model = load_yolov3_model(config.weight_path,
device,
checkpoint=config.from_ckpt,
mode='eval')
# model = load_yolov3_model("yolov3_original.pt", device, checkpoint=False, mode='eval')
# model = load_yolov3_model("ckpt_epoch_60.pt", device, checkpoint=False, mode='train')
# model = model.to(device)
# config.label_path
# load data
dataloader = load_dataset(type_=config.dataset_type,
img_dir=config.img_dir,
label_file=config.label_path,
img_size=config.img_size,
batch_size=config.batch_size,
n_cpu=config.n_cpu,
shuffle=False,
augment=False,
need_padding=True)
run_evaluation(model=model,
dataloader=dataloader,
device=device,
start_iter=config.start,
end_iter=config.stop,
print_every=False,
conf_thres=0.8,
nms_thres=0.4,
class_path="data/bdd100k.names")
return
def run_yolo_training(config):
# configure logging
current_datetime_str = datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_%S")
log_file_name_by_time = current_datetime_str + ".log"
if config.debug:
log_level = logging.DEBUG
elif config.verbose:
log_level = logging.INFO
else:
log_level = logging.WARNING
config_logging(config.log_dir, log_file_name_by_time, level=log_level)
# configure device
device = config_device(config.cpu_only)
checkpoint_dir = '{}/{}'.format(config.ckpt_dir, current_datetime_str)
os.makedirs(checkpoint_dir, exist_ok=True)
checkpoint = config.from_ckpt
dark = config.only_darknet
# checkpoint = False
model = load_yolov3_model(config.weight_path, device, checkpoint=checkpoint, mode='train', only_darknet=dark)
n_last_layers = config.n_last_layers
if config.n_last_layers == 0:
n_last_layers = "tail"
if n_last_layers != -1:
finetune_layers = model.yolo_last_n_layers(n_last_layers)
# finetune_layers = model.yolo_last_n_layers(opt.n_last_layers)
if n_last_layers != -1:
print("finetune layers:", n_last_layers)
for p in model.parameters():
p.requires_grad = False
for layer in finetune_layers:
layer.apply(init_layer_randomly)
for p in layer.parameters():
p.requires_grad_()
else:
for p in model.parameters():
p.requires_grad = True
model = model.to(device)
print("number of parameters:", get_n_params(model))
import numpy as np
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
params = sum([np.prod(p.size()) for p in model_parameters])
print("trainable parameters:", params)
# TODO: transfer learning
# for layer in model:
# layer.apply(init_layer_randomly)
# print parameters
# for name, param in model.named_parameters():
# print(name, param.size())
# if config.reset_weights:
# layer.apply(init_layer_randomly)
# for p in layer.parameters():
# p.requires_grad_()
# exit(-1)
# print(config.label_path)
dataloader = load_dataset(type_=config.dataset_type,
img_dir=config.img_dir,
label_file=config.label_path,
img_size=config.img_size,
batch_size=config.batch_size,
n_cpu=config.n_cpu,
shuffle=config.shuffle,
augment=config.data_augment)
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, model.parameters()),
lr=config.learning_rate,
)
run_training(model, optimizer, dataloader, device,
config.img_size,
config.n_epoch,
config.save_every_batch,
config.save_every_epoch,
checkpoint_dir)
# from eval import run_evaluation
# run_evaluation(model, dataloader, device, 0.5, 0, 0, 0, 2)
return
from models.yolov3 import load_yolov3_model
from datasets import webcam
import torch
from models.yolov3 import *
import time
from ytdl import *
cam_width = 1280
cam_height = 720
device = "cuda"
pretrained_model_path = "/Users/loki/Datasets/pretrained_models/bdd_epoch_100.pt"
model = load_yolov3_model(pretrained_model_path, device, checkpoint=True)
yt_video_url = "https://www.youtube.com/watch?v=7HaJArMDKgI"
# video_handle = get_yt_video(yt_video_url)
video_handle = "/Users/loki/Movies/video.mp4"
print(video_handle)
camera_dataset = webcam.WebCamStream(stream_url=video_handle,
width=cam_width,
height=cam_height,
transform="default",
force_res=True,
transform_params=416,