def from_model_folder(model_folder, load_stored_params=True, model_param_file=None,
iteration=None):
"""
Loads a DenseCorrespondenceNetwork from a model folder
:param model_folder: the path to the folder where the model is stored. This direction contains
files like
- 003500.pth
- training.yaml
:type model_folder:
:return: a DenseCorrespondenceNetwork objecc t
:rtype:
"""
model_folder = utils.convert_to_absolute_path(model_folder)
if model_param_file is None:
model_param_file, _, _ = utils.get_model_param_file_from_directory(model_folder, iteration=iteration)
model_param_file = utils.convert_to_absolute_path(model_param_file)
training_config_filename = os.path.join(model_folder, "training.yaml")
training_config = utils.getDictFromYamlFilename(training_config_filename)
config = training_config["dense_correspondence_network"]
config["path_to_network_params_folder"] = model_folder
fcn = resnet_dilated.Resnet34_8s(num_classes=config['descriptor_dimension'])
dcn = DenseCorrespondenceNetwork(fcn, config['descriptor_dimension'],
image_width=config['image_width'],
image_height=config['image_height'])
# load the stored params
if load_stored_params:
# old syntax
try:
dcn.load_state_dict(torch.load(model_param_file))
except:
logging.info("loading params with the new style failed, falling back to dcn.fcn.load_state_dict")
dcn.fcn.load_state_dict(torch.load(model_param_file))
# this is the new format
#
dcn.cuda()
dcn.train()
dcn.config = config
return dcn
def setup_logging_dir(self):
"""
Sets up the directory where logs will be stored and config
files written
:return: full path of logging dir
:rtype: str
"""
if 'logging_dir_name' in self._config['training']:
dir_name = self._config['training']['logging_dir_name']
else:
dir_name = utils.get_current_time_unique_name() +"_" + str(self._config['dense_correspondence_network']['descriptor_dimension']) + "d"
self._logging_dir_name = dir_name
self._logging_dir = os.path.join(utils.convert_to_absolute_path(self._config['training']['logging_dir']), dir_name)
if os.path.isdir(self._logging_dir):
shutil.rmtree(self._logging_dir)
if not os.path.isdir(self._logging_dir):
os.makedirs(self._logging_dir)
# make the tensorboard log directory
self._tensorboard_log_dir = os.path.join(self._logging_dir, "tensorboard")
if not os.path.isdir(self._tensorboard_log_dir):
os.makedirs(self._tensorboard_log_dir)
return self._logging_dir
def setup_logging_dir(self):
"""
Sets up the directory where logs will be stored and config
files written
:return: full path of logging dir
:rtype: str
"""
if 'logging_dir_name' in self._config['training']:
dir_name = self._config['training']['logging_dir_name']
else:
dir_name = utils.get_current_time_unique_name() +"_" + str(self._config['dense_correspondence_network']['descriptor_dimension']) + "d"
self._logging_dir_name = dir_name
self._logging_dir = os.path.join(utils.convert_to_absolute_path(self._config['training']['logging_dir']), dir_name)
if os.path.isdir(self._logging_dir):
shutil.rmtree(self._logging_dir)
if not os.path.isdir(self._logging_dir):
os.makedirs(self._logging_dir)
# make the tensorboard log directory
self._tensorboard_log_dir = os.path.join(self._logging_dir, "tensorboard")
if not os.path.isdir(self._tensorboard_log_dir):
os.makedirs(self._tensorboard_log_dir)
return self._logging_dir
def from_model_folder(model_folder,
load_stored_params=True,
model_param_file=None,
iteration=None):
"""
Loads a DenseCorrespondenceNetwork from a model folder
:param model_folder: the path to the folder where the model is stored. This direction contains
files like
- 003500.pth
- training.yaml
:type model_folder:
:return: a DenseCorrespondenceNetwork objecc t
:rtype:
"""
from_model_folder = False
model_folder = utils.convert_to_absolute_path(model_folder)
if model_param_file is None:
model_param_file, _, _ = utils.get_model_param_file_from_directory(
model_folder, iteration=iteration)
from_model_folder = True
model_param_file = utils.convert_to_absolute_path(model_param_file)
training_config_filename = os.path.join(model_folder, "training.yaml")
training_config = utils.getDictFromYamlFilename(
training_config_filename)
config = training_config["dense_correspondence_network"]
config["path_to_network_params_folder"] = model_folder
config["model_param_filename_tail"] = os.path.split(
model_param_file)[1]
dcn = DenseCorrespondenceNetwork.from_config(
config,
load_stored_params=load_stored_params,
model_param_file=model_param_file)
# whether or not network was constructed from model folder
dcn.constructed_from_model_folder = from_model_folder
dcn.model_folder = model_folder
return dcn
def load_training_dataset(self):
"""
Loads the dataset that this was trained on
:return: a dataset object, loaded with the config as set in the dataset.yaml
:rtype: SpartanDataset
"""
network_params_folder = self.path_to_network_params_folder
network_params_folder = utils.convert_to_absolute_path(network_params_folder)
dataset_config_file = os.path.join(network_params_folder, 'dataset.yaml')
config = utils.getDictFromYamlFilename(dataset_config_file)
return SpartanDataset(config_expanded=config)
def descriptor_image_stats(self):
"""
Returns the descriptor normalization parameters, if possible.
If they have not yet been loaded then it loads them
:return:
:rtype:
"""
# if it isn't already set, then attempt to load it
if self._descriptor_image_stats is None:
path_to_params = utils.convert_to_absolute_path(self.path_to_network_params_folder)
descriptor_stats_file = os.path.join(path_to_params, "descriptor_statistics.yaml")
self._descriptor_image_stats = utils.getDictFromYamlFilename(descriptor_stats_file)
return self._descriptor_image_stats
def from_config(config, load_stored_params=True):
"""
Load a network from a config file
:param load_stored_params: whether or not to load stored params, if so there should be
a "path_to_network" entry in the config
:type load_stored_params: bool
:param config: Dict specifying details of the network architecture
e.g.
path_to_network: /home/manuelli/code/dense_correspondence/recipes/trained_models/10_drill_long_3d
parameter_file: dense_resnet_34_8s_03505.pth
descriptor_dimensionality: 3
image_width: 640
image_height: 480
:return: DenseCorrespondenceNetwork
:rtype:
"""
fcn = resnet_dilated.Resnet34_8s(num_classes=config['descriptor_dimension'])
if load_stored_params:
path_to_network_params = utils.convert_to_absolute_path(config['path_to_network_params'])
config['path_to_network_params_folder'] = os.path.dirname(config['path_to_network_params'])
fcn.load_state_dict(torch.load(path_to_network_params))
dcn = DenseCorrespondenceNetwork(fcn, config['descriptor_dimension'],
image_width=config['image_width'],
image_height=config['image_height'])
dcn.cuda()
dcn.train()
dcn.config = config
return dcn
'training.yaml')
train_config = utils.getDictFromYamlFilename(train_config_file)
dataset = SpartanDataset(config=config)
logging_dir = "code/data_volume/pdc/trained_models/tutorials"
num_iterations = 3500
d = 3 # the descriptor dimension
name = "caterpillar_%d" % (d)
train_config["training"]["logging_dir_name"] = name
train_config["training"]["logging_dir"] = logging_dir
train_config["dense_correspondence_network"]["descriptor_dimension"] = d
train_config["training"]["num_iterations"] = num_iterations
TRAIN = True
EVALUATE = True
if TRAIN:
print "training descriptor of dimension %d" % (d)
train = DenseCorrespondenceTraining(dataset=dataset, config=train_config)
train.run()
print "finished training descriptor of dimension %d" % (d)
model_folder = os.path.join(logging_dir, name)
model_folder = utils.convert_to_absolute_path(model_folder)
if EVALUATE:
DCE = DenseCorrespondenceEvaluation
num_image_pairs = 100
DCE.run_evaluation_on_network(model_folder,
num_image_pairs=num_image_pairs)
import numpy as np
import os
import fnmatch
import pandas as pd
import sklearn.metrics as sm
import scipy.stats as ss
import matplotlib.pyplot as plt
import dense_correspondence_manipulation.utils.utils as utils
utils.add_dense_correspondence_to_python_path()
from dense_correspondence.evaluation.evaluation import DenseCorrespondenceEvaluationPlotter as DCEP
folder_name = "tutorials"
path_to_nets = os.path.join("../pdc/trained_models", folder_name)
path_to_nets = utils.convert_to_absolute_path(path_to_nets)
all_nets = sorted(os.listdir(path_to_nets))
nets_to_plot = []
nets_list = ["caterpillar_3"]
for net in nets_list:
nets_to_plot.append(os.path.join(folder_name, net))
p = DCEP()
dc_source_dir = utils.getDenseCorrespondenceSourceDir()
network_name = nets_to_plot[0]
path_to_csv = os.path.join(dc_source_dir, "../", "pdc", "trained_models",
network_name, "analysis/train/data.csv")
fig_axes = DCEP.run_on_single_dataframe(path_to_csv,
label=network_name,
