def __init__(self, plugin_file_name: str, name: str = 'plugin-1'):
r"""
Loads a custom python file specified in `opprogram`, which
should contain a callable named "exec" such that
a call of `op_call(chunk, args)` operates on the chunk.
"""
super().__init__(name=name)
if not plugin_file_name.endswith('.py'):
plugin_file_name += '.py'
plugin_dir = path.join(path.dirname(path.realpath(__file__)),
'../plugins')
plugin_dir1 = path.join(plugin_dir,
'chunkflow-plugins/chunkflowplugins')
plugin_dirs = ['./', plugin_dir, plugin_dir1]
if 'CHUNKFLOW_PLUGIN_DIR' in os.environ:
plugin_dirs.append(os.environ['CHUNKFLOW_PLUGIN_DIR'])
for plugin_dir in plugin_dirs:
fname = path.join(plugin_dir, plugin_file_name)
if path.exists(fname):
logging.info(f'loading plugin {fname}')
program = load_source(fname)
# assuming this is a func / static functor for now, maybe make it a class?
self.execute = program.execute
break
assert os.path.exists(fname), f'did not find plugin: {fname}'
assert hasattr(self, 'execute')
def __init__(self, plugin_file: str, name: str = 'plugin-1'):
r"""
Loads a custom python file specified in `opprogram`, which
should contain a callable named "exec" such that
a call of `op_call(chunk, args)` operates on the chunk.
"""
super().__init__(name=name)
if not plugin_file.endswith('.py'):
plugin_file += '.py'
if not path.exists(plugin_file):
plugin_file = path.join(path.dirname(path.realpath(__file__)),
'../plugins', path.basename(plugin_file))
if not path.exists(plugin_file):
plugin_file = path.join(
path.dirname(path.realpath(__file__)),
'../plugins/chunkflow-plugins/chunkflowplugins',
path.basename(plugin_file))
assert path.exists(plugin_file)
program = load_source(plugin_file)
# assuming this is a func / static functor for now, maybe make it a class?
self.execute = program.execute
def __init__(self,
patch_size: Union[tuple, list],
patch_overlap: Union[tuple, list],
model_file_name: str,
weight_file_name: str,
use_batch_norm: bool = True,
is_static_batch_norm: bool = False,
num_output_channels: int = 3,
mask: np.ndarray = None):
super().__init__(patch_size, patch_overlap)
self.num_output_channels = num_output_channels
if torch.cuda.is_available():
self.is_gpu = True
# put mask to gpu
self.mask = torch.from_numpy(self.mask).cuda()
else:
self.is_gpu = False
net_source = load_source(model_file_name)
if hasattr(net_source, "load_model"):
self.net = net_source.load_model(weight_file_name)
else:
self.net = net_source.InstantiatedModel
chkpt = torch.load(weight_file_name)
state_dict = chkpt['state_dict'] if 'state_dict' in chkpt else chkpt
self.net.load_state_dict(state_dict)
if self.is_gpu:
self.net = self.net.cuda()
# data parallel do not work with old emvision net
#self.net = torch.nn.DataParallel(
# self.net, device_ids=range(torch.cuda.device_count()))
# Print model's state_dict
#print("Model's state_dict:")
#for param_tensor in self.net.state_dict():
# print(param_tensor, "\t", self.net.state_dict()[param_tensor].size())
if use_batch_norm and is_static_batch_norm:
self.net.eval()
if hasattr(net_source, "pre_process"):
self.pre_process = net_source.pre_process
else:
self.pre_process = self._pre_process
if hasattr(net_source, "post_process"):
self.post_process = net_source.post_process
else:
self.post_process = self._identity
def __init__(self, convnet_model: str, convnet_weight_path: str,
input_patch_size: tuple,
output_patch_size: tuple,
output_patch_overlap: tuple,
num_output_channels: int = 1,
dtype: str='float32',
bump: str='wu'):
# To-Do: support zung function
assert bump == 'wu'
super().__init__(input_patch_size, output_patch_size,
output_patch_overlap, num_output_channels,
dtype=dtype)
self.num_output_channels = num_output_channels
net_source = load_source(convnet_model)
assert hasattr(net_source, "PatchInferencer")
self.patch_inferencer = net_source.PatchInferencer(
convnet_weight_path,
self.output_patch_mask,)
def __init__(self,
convnet_model: str,
convnet_weight_path: str,
input_patch_size: tuple,
output_patch_size: tuple,
output_patch_overlap: tuple,
num_output_channels: int = 1,
dtype: str = 'float32',
bump: str = 'wu'):
# To-Do: support zung function
assert bump == 'wu'
super().__init__(input_patch_size,
output_patch_size,
output_patch_overlap,
num_output_channels,
dtype=dtype)
self.num_output_channels = num_output_channels
if torch.cuda.is_available():
self.is_gpu = True
# put mask to gpu
self.output_patch_mask = torch.from_numpy(
self.output_patch_mask).cuda()
else:
self.is_gpu = False
net_source = load_source(convnet_model)
if hasattr(net_source, "load_model"):
self.model = net_source.load_model(convnet_weight_path)
else:
self.model = net_source.InstantiatedModel
if self.is_gpu:
map_location = 'cuda'
else:
map_location = 'cpu'
chkpt = torch.load(convnet_weight_path, map_location=map_location)
state_dict = chkpt['state_dict'] if 'state_dict' in chkpt else chkpt
self.model.load_state_dict(state_dict)
if self.is_gpu and next(self.model.parameters()).is_cuda:
self.model.cuda()
# data parallel do not work with old emvision net
#self.model = torch.nn.DataParallel(
# self.model, device_ids=range(torch.cuda.device_count()))
# Print model's state_dict
#print("Model's state_dict:")
#for param_tensor in self.model.state_dict():
# print(param_tensor, "\t", self.model.state_dict()[param_tensor].size())
if hasattr(net_source, "pre_process"):
self.pre_process = net_source.pre_process
else:
self.pre_process = self._pre_process
if hasattr(net_source, "post_process"):
self.post_process = net_source.post_process
else:
self.post_process = self._identity