def MiDaS(pretrained=True, **kwargs):
""" # This docstring shows up in hub.help()
MiDaS model for monocular depth estimation
pretrained (bool): load pretrained weights into model
"""
model = MidasNet()
if pretrained:
checkpoint = (
"https://github.com/intel-isl/MiDaS/releases/download/v2/model-f46da743.pt"
)
state_dict = torch.hub.load_state_dict_from_url(checkpoint,
progress=True,
check_hash=True)
model.load_state_dict(state_dict)
return model
def __init__(self):
'''Initialize ros publisher, ros subscriber'''
# topic where we publish
self.bridge = CvBridge()
self.image_depth_pub = rospy.Publisher("/midas/depth/image_raw",
Image,
queue_size=1)
self.image_rgb_pub = rospy.Publisher("/midas/rgb/image_raw",
Image,
queue_size=1)
self.camera_info_pub = rospy.Publisher("/midas/camera_info",
CameraInfo,
queue_size=1)
# subscribed Topic
self.subscriber = rospy.Subscriber("/midas_rgb/image_raw",
Image,
self.callback,
queue_size=1)
# setup image display
self.display_rgb = False
self.display_depth = True
# initialize Intel MiDas
self.initialized_midas = False
rospack = rospkg.RosPack()
ros_pkg_path = rospack.get_path('intelisl_midas_ros')
model_path = os.path.join(ros_pkg_path, 'src/model-f6b98070.pt')
self.model = MidasNet(model_path, non_negative=True)
self.device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
self.model.to(self.device)
self.model.eval()
rospy.loginfo('Loaded Intel MiDaS')
midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms")
self.transform = midas_transforms.default_transform
rospy.loginfo('Initialized Intel MiDaS transform')
self.initialized_midas = True
def init_model(transform):
# set torch options
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
model_path = "../MiDaS/model-f46da743.pt"
print("initialize")
# select device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % device)
# load network
model = MidasNet(model_path, non_negative=True)
transform = Compose(
[
Resize(
384,
384,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
]
)
model.to(device)
model.eval()
return (model, transform, device), None
def forward(self, x):
"""Forward pass.
Args:
x (tensor): input data (image)
Returns:
tensor: depth
"""
mean = torch.tensor([0.485, 0.456, 0.406])
std = torch.tensor([0.229, 0.224, 0.225])
x.sub_(mean[None, :, None, None]).div_(std[None, :, None, None])
return MidasNet.forward(self, x)
def __init__(self, model_type, model_path, optimize):
print("initialize")
# select device
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % self.device)
# load network
if model_type == "large":
self.model = MidasNet(model_path, non_negative=True)
self.net_w, self.net_h = 384, 384
elif model_type == "small":
self.model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True,
non_negative=True, blocks={'expand': True})
self.net_w, self.net_h = 256, 256
else:
print(f"model_type '{model_type}' not implemented, use: --model_type large")
assert False
self.transform = Compose(
[
Resize(
self.net_w,
self.net_h,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
]
)
self.model.eval()
self.optimize = optimize
if self.optimize:
rand_example = torch.rand(1, 3, self.net_h, self.net_w)
self.model(rand_example)
traced_script_module = torch.jit.trace(self.model, rand_example)
self.model = traced_script_module
if self.device == torch.device("cuda"):
self.model = self.model.to(memory_format=torch.channels_last)
self.model = self.model.half()
self.model.to(self.device)
def convert(in_model_path, out_model_path):
"""Run MiDaS to create the torchscript model.
https://pytorch.org/tutorials/advanced/cpp_export.html
:param in_model_path: the path to the pre-trained model
:param out_model_path: the output filename
"""
# select device
device = torch.device("cuda")
print("device: %s" % device)
# load network
example_input = torch.rand(1, 3, 288, 384, dtype=torch.float32)
model = MidasNet(in_model_path, non_negative=True)
sm = torch.jit.trace(model, example_input)
# Save the torchscript model
sm.save(out_model_path)
def init_model(transform):
parser = argparse.ArgumentParser()
parser.add_argument('-mw', '--model_weights',
default='model-f6b98070.pt',
help='path to the trained weights of model'
)
parser.add_argument('-mt', '--model_type',
default='large',
help='model type: large or small'
)
parser.add_argument('--optimize', dest='optimize', action='store_true')
parser.add_argument('--no-optimize', dest='optimize', action='store_false')
parser.set_defaults(optimize=True)
args, unknown = parser.parse_known_args()
# set torch options
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print("initialize")
# select device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % device)
# load network
if args.model_type == "large":
model_path = "../MiDaS/"+args.model_weights
model = MidasNet(model_path, non_negative=True)
net_w, net_h = 384, 384
elif args.model_type == "small":
if "small" not in args.model_weights:
args.model_weights = "model-small-70d6b9c8.pt"
model_path = "../MiDaS/"+args.model_weights
model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True, non_negative=True, blocks={'expand': True})
net_w, net_h = 256, 256
else:
print(f"model_type '{model_type}' not implemented, use: --model_type large")
assert False
transform = Compose(
[
Resize(
net_w,
net_h,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
]
)
model.eval()
if args.optimize==True:
rand_example = torch.rand(1, 3, net_h, net_w)
model(rand_example)
traced_script_module = torch.jit.trace(model, rand_example)
model = traced_script_module
if device == torch.device("cuda"):
model = model.to(memory_format=torch.channels_last)
model = model.half()
model.to(device)
return (model, transform, device, args.optimize), args
def run(input_path,
output_path,
model_path,
model_type="large",
optimize=True):
"""Run MonoDepthNN to compute depth maps.
Args:
input_path (str): path to input folder
output_path (str): path to output folder
model_path (str): path to saved model
"""
print("initialize")
# select device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % device)
# load network
if model_type == "large":
model = MidasNet(model_path, non_negative=True)
net_w, net_h = 384, 384
elif model_type == "small":
model = MidasNet_small(model_path,
features=64,
backbone="efficientnet_lite3",
exportable=True,
non_negative=True,
blocks={'expand': True})
net_w, net_h = 256, 256
else:
print(
f"model_type '{model_type}' not implemented, use: --model_type large"
)
assert False
transform = Compose([
Resize(
net_w,
net_h,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
])
model.eval()
if optimize == True:
rand_example = torch.rand(1, 3, net_h, net_w)
model(rand_example)
traced_script_module = torch.jit.trace(model, rand_example)
model = traced_script_module
if device == torch.device("cuda"):
model = model.to(memory_format=torch.channels_last)
model = model.half()
model.to(device)
# get input
img_names = glob.glob(os.path.join(input_path, "*"))
num_images = len(img_names)
# create output folder
os.makedirs(output_path, exist_ok=True)
print("start processing")
for ind, img_name in enumerate(img_names):
print(" processing {} ({}/{})".format(img_name, ind + 1, num_images))
# input
img = utils.read_image(img_name)
img_input = transform({"image": img})["image"]
# compute
with torch.no_grad():
sample = torch.from_numpy(img_input).to(device).unsqueeze(0)
if optimize == True and device == torch.device("cuda"):
sample = sample.to(memory_format=torch.channels_last)
sample = sample.half()
prediction = model.forward(sample)
prediction = (torch.nn.functional.interpolate(
prediction.unsqueeze(1),
size=img.shape[:2],
mode="bicubic",
align_corners=False,
).squeeze().cpu().numpy())
prediction /= 1000
# output
filename = os.path.join(
output_path,
os.path.splitext(os.path.basename(img_name))[0])
utils.write_depth(filename, prediction, bits=2)
print(prediction)
print(prediction.shape)
print("finished")
def run(input_path, output_path, model_path):
"""Run MonoDepthNN to compute depth maps.
Args:
input_path (str): path to input folder
output_path (str): path to output folder
model_path (str): path to saved model
"""
print("initialize")
# select device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % device)
# load network
model = MidasNet(model_path, non_negative=True)
transform = Compose([
Resize(
384,
384,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
])
model.to(device)
model.eval()
# get input
img_names = glob.glob(os.path.join(input_path, "*"))
num_images = len(img_names)
# create output folder
os.makedirs(output_path, exist_ok=True)
print("start processing")
for ind, img_name in enumerate(img_names):
print(" processing {} ({}/{})".format(img_name, ind + 1, num_images))
# input
img = utils.read_image(img_name)
img_input = transform({"image": img})["image"]
# compute
with torch.no_grad():
sample = torch.from_numpy(img_input).to(device).unsqueeze(0)
prediction = model.forward(sample)
prediction = (torch.nn.functional.interpolate(
prediction.unsqueeze(1),
size=img.shape[:2],
mode="bicubic",
align_corners=False,
).squeeze().cpu().numpy())
# output
filename = os.path.join(
output_path,
os.path.splitext(os.path.basename(img_name))[0])
utils.write_depth(filename, prediction, bits=2)
print("finished")
def run(model_path):
"""
Run MonoDepthNN to compute depth maps.
"""
# set torch options
torch.cuda.empty_cache()
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
# select device
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
print("device: %s" % device)
# load network
model = MidasNet(model_path, non_negative=True)
transform = Compose([
Resize(
384,
384,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
])
model.to(device)
model.eval()
cam = cv2.VideoCapture(0)
cam.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cam.set(cv2.CAP_PROP_FRAME_HEIGHT, 360)
cam.set(cv2.CAP_PROP_FPS, 30)
while True:
t = time.time()
_, left_img = cam.read()
image = cv2.cvtColor(left_img, cv2.COLOR_BGR2RGB) / 255.0
# Apply transforms
image = transform({"image": image})["image"]
# Predict and resize to original resolution
with torch.no_grad():
image = torch.from_numpy(image).to(device).unsqueeze(0)
depth = model.forward(image)
depth = (torch.nn.functional.interpolate(
depth.unsqueeze(1),
size=left_img.shape[:2],
mode="bicubic",
align_corners=False,
).squeeze().cpu().numpy())
depth_map = write_depth(depth, bits=2, reverse=False)
right_img = generate_stereo(left_img, depth_map)
anaglyph = overlap(left_img, right_img)
cv2.imshow("anaglyph", anaglyph)
fps = 1. / (time.time() - t)
print('\rframerate: %f fps' % fps, end='')
cv2.waitKey(1)
def main():
global args, best_result, output_directory
# set random seed
torch.manual_seed(args.manual_seed)
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
args.batch_size = args.batch_size * torch.cuda.device_count()
else:
print("Let's use GPU ", torch.cuda.current_device())
train_loader, val_loader = create_loader(args)
if args.resume:
assert os.path.isfile(args.resume), \
"=> no checkpoint found at '{}'".format(args.resume)
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch'] + 1
best_result = checkpoint['best_result']
optimizer = checkpoint['optimizer']
# model_dict = checkpoint['model'].module.state_dict() # to load the trained model using multi-GPUs
# model = FCRN.ResNet(output_size=train_loader.dataset.output_size, pretrained=False)
# model.load_state_dict(model_dict)
# solve 'out of memory'
model = checkpoint['model']
print("=> loaded checkpoint (epoch {})".format(checkpoint['epoch']))
# clear memory
del checkpoint
# del model_dict
torch.cuda.empty_cache()
else:
print("=> creating Model")
model = MidasNet()
print("=> model created.")
start_epoch = 0
# different modules have different learning rate
train_params = [{
'params': model.pretrained.parameters(),
'lr': args.lr
}, {
'params': model.scratch.parameters(),
'lr': args.lr * 10
}]
optimizer = torch.optim.Adam(train_params,
lr=args.lr,
betas=args.betas,
weight_decay=args.weight_decay)
# You can use DataParallel() whether you use Multi-GPUs or not
model = nn.DataParallel(model).cuda()
# when training, use reduceLROnPlateau to reduce learning rate
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
patience=args.lr_patience)
# loss function
criterion = criteria.ScaleAndShiftInvariantLoss()
# create directory path
output_directory = utils.get_output_directory(args)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
best_txt = os.path.join(output_directory, 'best.txt')
config_txt = os.path.join(output_directory, 'config.txt')
# write training parameters to config file
if not os.path.exists(config_txt):
with open(config_txt, 'w') as txtfile:
args_ = vars(args)
args_str = ''
for k, v in args_.items():
args_str = args_str + str(k) + ':' + str(v) + ',\t\n'
txtfile.write(args_str)
# create log
log_path = os.path.join(
output_directory, 'logs',
datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname())
if os.path.isdir(log_path):
shutil.rmtree(log_path)
os.makedirs(log_path)
logger = SummaryWriter(log_path)
for epoch in range(start_epoch, args.epochs):
# remember change of the learning rate
for i, param_group in enumerate(optimizer.param_groups):
old_lr = float(param_group['lr'])
logger.add_scalar('Lr/lr_' + str(i), old_lr, epoch)
train(train_loader, model, criterion, optimizer, epoch,
logger) # train for one epoch
result, img_merge = validate(val_loader, model, epoch,
logger) # evaluate on validation set
# remember best rmse and save checkpoint
is_best = result.rmse < best_result.rmse
if is_best:
best_result = result
with open(best_txt, 'w') as txtfile:
txtfile.write(
"epoch={}, rmse={:.3f}, rml={:.3f}, log10={:.3f}, d1={:.3f}, d2={:.3f}, dd31={:.3f}, "
"t_gpu={:.4f}".format(epoch, result.rmse, result.absrel,
result.lg10, result.delta1,
result.delta2, result.delta3,
result.gpu_time))
if img_merge is not None:
img_filename = output_directory + '/comparison_best.png'
utils.save_image(img_merge, img_filename)
# save checkpoint for each epoch
utils.save_checkpoint(
{
'args': args,
'epoch': epoch,
'model': model,
'best_result': best_result,
'optimizer': optimizer,
}, is_best, epoch, output_directory)
# when rml doesn't fall, reduce learning rate
scheduler.step(result.absrel)
logger.close()
class MiDaSROS:
def __init__(self):
'''Initialize ros publisher, ros subscriber'''
# topic where we publish
self.bridge = CvBridge()
self.image_depth_pub = rospy.Publisher("/midas/depth/image_raw",
Image,
queue_size=1)
self.image_rgb_pub = rospy.Publisher("/midas/rgb/image_raw",
Image,
queue_size=1)
self.camera_info_pub = rospy.Publisher("/midas/camera_info",
CameraInfo,
queue_size=1)
# subscribed Topic
self.subscriber = rospy.Subscriber("/midas_rgb/image_raw",
Image,
self.callback,
queue_size=1)
# setup image display
self.display_rgb = False
self.display_depth = True
# initialize Intel MiDas
self.initialized_midas = False
rospack = rospkg.RosPack()
ros_pkg_path = rospack.get_path('intelisl_midas_ros')
model_path = os.path.join(ros_pkg_path, 'src/model-f6b98070.pt')
self.model = MidasNet(model_path, non_negative=True)
self.device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
self.model.to(self.device)
self.model.eval()
rospy.loginfo('Loaded Intel MiDaS')
midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms")
self.transform = midas_transforms.default_transform
rospy.loginfo('Initialized Intel MiDaS transform')
self.initialized_midas = True
def show_image(self, img, window_name="Image Window"):
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
cv2.imshow(window_name, img)
cv2.waitKey(2)
def callback(self, img_msg):
# conversion to OpenCV and the correct color
img = cv2.cvtColor(
self.bridge.imgmsg_to_cv2(img_msg, desired_encoding='passthrough'),
cv2.COLOR_BGR2RGB)
if self.display_rgb:
self.show_image(img, window_name='Ground Truth RGB')
# convert RGB to depth using MiDaS
if self.initialized_midas:
input_batch = self.transform(img).to(self.device)
with torch.no_grad():
prediction = self.model(input_batch)
prediction = torch.nn.functional.interpolate(
prediction.unsqueeze(1),
size=img.shape[:2],
mode="bicubic",
align_corners=False,
).squeeze()
# scale pixel values to display
omax, omin = prediction.max(), prediction.min()
prediction = (prediction - omin) / (omax - omin)
# convert depth prediction to numpy
output = prediction.cpu().numpy()
if self.display_depth:
self.show_image(output, window_name='Estimated Depth')
# setup message (depth)
depth_msg = self.bridge.cv2_to_imgmsg(output,
encoding="passthrough")
# setup message camera info
camera_info_msg = CameraInfo()
camera_info_msg.header.stamp = img_msg.header.stamp
camera_info_msg.height = img.shape[0]
camera_info_msg.width = img.shape[1]
# publish
self.image_depth_pub.publish(depth_msg)
self.image_rgb_pub.publish(img_msg)
self.camera_info_pub.publish(camera_info_msg)
def run(model_path):
"""
Run MonoDepthNN to compute depth maps.
"""
# Input images
img_list = os.listdir(args.input)
img_list.sort()
# output dir
output_dir = './depth'
os.makedirs(output_dir, exist_ok=True)
# set torch options
torch.cuda.empty_cache()
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
# select device
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
print("device: %s" % device)
# load network
model = MidasNet(model_path, non_negative=True)
transform = Compose([
Resize(
384,
384,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
PrepareForNet(),
])
model.to(device)
model.eval()
for idx in tqdm(range(len(img_list))):
sample = img_list[idx]
raw_image = cv2.imread(os.path.join(args.input, sample))
raw_image = cv2.cvtColor(raw_image, cv2.COLOR_BGR2RGB) / 255.0
# Apply transforms
image = transform({"image": raw_image})["image"]
# Predict and resize to original resolution
with torch.no_grad():
image = torch.from_numpy(image).to(device).unsqueeze(0)
prediction = model.forward(image)
prediction = (torch.nn.functional.interpolate(
prediction.unsqueeze(1),
size=raw_image.shape[:2],
mode="bicubic",
align_corners=False,
).squeeze().cpu().numpy())
depth_map = write_depth(prediction, bits=2, reverse=False)
cv2.imwrite(
os.path.join(output_dir,
'MiDaS_{}.png'.format(sample.split('.')[0])),
depth_map)
def __init__(self):
self.device = "cuda" if torch.cuda.is_available() else "cpu"
# Setup AdaBins model
self.adabins_nyu_infer_helper = InferenceHelper(dataset='nyu',
device=self.device)
self.adabins_kitti_infer_helper = InferenceHelper(dataset='kitti',
device=self.device)
# Setup DiverseDepth model
class DiverseDepthArgs:
def __init__(self):
self.resume = False
self.cfg_file = "lib/configs/resnext50_32x4d_diversedepth_regression_vircam"
self.load_ckpt = "pretrained/DiverseDepth.pth"
diverse_depth_args = DiverseDepthArgs()
merge_cfg_from_file(diverse_depth_args)
self.diverse_depth_model = RelDepthModel()
self.diverse_depth_model.eval()
# load checkpoint
load_ckpt(diverse_depth_args, self.diverse_depth_model)
# TODO: update this - see how `device` argument should be processsed
if self.device == "cuda":
self.diverse_depth_model.cuda()
self.diverse_depth_model = torch.nn.DataParallel(
self.diverse_depth_model)
# Setup MiDaS model
self.midas_model_path = "./pretrained/MiDaS_f6b98070.pt"
midas_model_type = "large"
# load network
if midas_model_type == "large":
self.midas_model = MidasNet(self.midas_model_path,
non_negative=True)
self.midas_net_w, self.midas_net_h = 384, 384
elif midas_model_type == "small":
self.midas_model = MidasNet_small(self.midas_model_path,
features=64,
backbone="efficientnet_lite3",
exportable=True,
non_negative=True,
blocks={'expand': True})
self.midas_net_w, self.midas_net_h = 256, 256
self.midas_transform = Compose([
Resize(
self.midas_net_w,
self.midas_net_h,
resize_target=None,
keep_aspect_ratio=True,
ensure_multiple_of=32,
resize_method="upper_bound",
image_interpolation_method=cv2.INTER_CUBIC,
),
NormalizeImage(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
PrepareForNet(),
])
self.midas_model.eval()
self.midas_optimize = True
if self.midas_optimize == True:
rand_example = torch.rand(1, 3, self.midas_net_h, self.midas_net_w)
self.midas_model(rand_example)
traced_script_module = torch.jit.trace(self.midas_model,
rand_example)
self.midas_model = traced_script_module
if self.device == "cuda":
self.midas_model = self.midas_model.to(
memory_format=torch.channels_last)
self.midas_model = self.midas_model.half()
self.midas_model.to(torch.device(self.device))
# Setup SGDepth model
self.sgdepth_model = InferenceEngine.SgDepthInference()
# Setup monodepth2 model
self.monodepth2_model_path = "pretrained/monodepth2_mono+stereo_640x192"
monodepth2_device = torch.device(self.device)
encoder_path = os.path.join(self.monodepth2_model_path, "encoder.pth")
depth_decoder_path = os.path.join(self.monodepth2_model_path,
"depth.pth")
# LOADING PRETRAINED MODEL
print(" Loading Monodepth2 pretrained encoder")
self.monodepth2_encoder = networks.ResnetEncoder(18, False)
loaded_dict_enc = torch.load(encoder_path,
map_location=monodepth2_device)
# extract the height and width of image that this model was trained with
self.feed_height = loaded_dict_enc['height']
self.feed_width = loaded_dict_enc['width']
filtered_dict_enc = {
k: v
for k, v in loaded_dict_enc.items()
if k in self.monodepth2_encoder.state_dict()
}
self.monodepth2_encoder.load_state_dict(filtered_dict_enc)
self.monodepth2_encoder.to(monodepth2_device)
self.monodepth2_encoder.eval()
print(" Loading pretrained decoder")
self.monodepth2_depth_decoder = networks.DepthDecoder(
num_ch_enc=self.monodepth2_encoder.num_ch_enc, scales=range(4))
loaded_dict = torch.load(depth_decoder_path,
map_location=monodepth2_device)
self.monodepth2_depth_decoder.load_state_dict(loaded_dict)
self.monodepth2_depth_decoder.to(monodepth2_device)
self.monodepth2_depth_decoder.eval()
'truth_thresh':
1,
'random':
1,
'stride': [32, 16, 8]
}
plane_segmentation_cfg = {
"meta_data_path":
"G:/EVA5/ToGit/Planercnn/content/planercnn/test/inference/"
}
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device: %s" % device)
midas_model = MidasNet(r"G:\EVA5\ToGit\model-f6b98070.pt",
non_negative=True)
midas_model.eval()
midas_model.to(device)
#print(midas_model)
print("Model Loaded")
# model = CustomNet("model-f46da743.pt", non_negative=True, yolo_cfg=yolo_cfg)
model = CustomNet("G:\EVA5\ToGit\yolov3-spp-ultralytics.pt",
non_negative=True,
yolo_cfg=yolo_cfg)
model.gr = 1.0
model.hyp = hyp
model.to(device)
#print(model)
