def __init__(self, data, target, dropout, kw):
super(MDGRUClassification, self).__init__(data, target, dropout, kw)
self.ignore_label = argget(kw, "ignore_label", None)
self.fc_channels = argget(kw, "fc_channels", [25, 45, self.nclasses])
self.mdgru_channels = argget(kw, "mdgru_channels", [16, 32, 64])
self.strides = argget(kw, "strides",
[None for _ in self.mdgru_channels])
def __init__(self, data, dropout, kw):
super(GANModel, self).__init__(data, dropout, None, kw)
self.dropout = dropout
self.learning_rate = argget(kw, "learning_rate", 0.001)
self.momentum = argget(kw, "momentum", 0.9)
self.nclasses = argget(kw, "nclasses", 2)
self.fakedata = argget(kw, "fakedata", None)
def __init__(self, data, target, dropout, kw):
super(RegressionModel, self).__init__(data, target, dropout, kw)
self.target = target
self.dropout = dropout
self.learning_rate = argget(kw, "learning_rate", 0.001)
self.nclasses = argget(kw, "nclasses", 1)
self.momentum = argget(kw, "momentum", 0.9)
def __init__(self, data_shape, dropout, kw):
super(MDGRUClassification, self).__init__(data_shape, dropout, kw)
my_kw, kw = compile_arguments(MDGRUClassification, kw, transitive=False)
for k, v in my_kw.items():
setattr(self, k, v)
self.fc_channels = argget(kw, "fc_channels", [25, 45, self.nclasses])
self.mdgru_channels = argget(kw, "mdgru_channels", [16, 32, 64])
self.strides = argget(kw, "strides", [None for _ in self.mdgru_channels])
self.data_shape = data_shape
# create logits:
logits = []
num_spatial_dims = len(data_shape[2:])
last_output_channel_size = data_shape[1]
for it, (mdgru, fcc, s) in enumerate(zip(self.mdgru_channels, self.fc_channels, self.strides)):
mdgru_kw = {}
mdgru_kw.update(kw)
if it == len(self.mdgru_channels) - 1:
mdgru_kw["noactivation"] = True
if s is not None:
mdgru_kw["strides"] = [s for _ in range(num_spatial_dims)] if np.isscalar(s) else s
logits += [MDGRUBlock(num_spatial_dims, self.dropout, last_output_channel_size, mdgru, fcc, mdgru_kw)]
last_output_channel_size = fcc if fcc is not None else mdgru
self.model = th.nn.Sequential(*logits)
self.losses = th.nn.modules.CrossEntropyLoss()
print(self.model)
def __init__(self, num_input, num_units, kw):
super(CRNNCell, self).__init__()
crnn_kw, kw = compile_arguments(CRNNCell, kw, transitive=False)
for k, v in crnn_kw.items():
setattr(self, k, v)
self._num_units = num_units
self._num_inputs = num_input
self.filter_size_x = argget(kw, "filter_size_x", [7, 7])
self.filter_size_h = argget(kw, "filter_size_h", [7, 7])
self.strides = argget(kw, "strides", None)
def __init__(self, data, target, dropout, kw):
super(MDGRUClassificationWithGeneralizedDiceLoss,
self).__init__(data, target, dropout, kw)
self.dice_loss_label = argget(kw, "dice_loss_label", [])
self.dice_loss_weight = argget(kw, "dice_loss_weight", [])
self.dice_autoweighted = argget(kw, "dice_autoweighted", False)
if len(self.dice_loss_label) != len(
self.dice_loss_weight) and not self.dice_autoweighted:
raise Exception(
"dice_loss_label and dice_loss_weight need to be of the same length"
)
def __init__(self, myshape, num_units, kw):
"""Base convolutional RNN method, implements common functions and serves as abstract class.
Property defaults contains default values for all properties of a CGRUCell that are the same for one MDGRU
and is used to filter valid arguments.
Parameters
----------
myshape : list
Contains shape information on the input tensor.
num_units : int
Defines number of output channels.
activation : tensorflow activation function
Can be used to override tanh as activation function.
periodic_convolution_x : bool
Enables circular convolution for the input
periodic_convolution_h : bool
Enables circular convolution for the last output / state
dropconnectx : tensorflow placeholder or None
keeprate of dropconnect regularization on weights connecting to input
dropconnecth : tensorflow placeholder or None
keeprate of dropconnect regularization on weights connecting to previous state / output
use_bernoulli : bool
decide if bernoulli or Gaussian distributions should be used for the weight distributions with dropconnect
"""
super(CRNNCell, self).__init__()
crnn_kw, kw = compile_arguments(CRNNCell, kw, transitive=False)
for k, v in crnn_kw.items():
setattr(self, k, v)
self._num_units = num_units
self.filter_size_x = argget(kw, "filter_size_x", [7, 7])
self.filter_size_h = argget(kw, "filter_size_h", [7, 7])
self.strides = argget(kw, "strides", None)
if myshape is None:
raise Exception("myshape cant be None!")
myshapein = deepcopy(myshape)
myshapein.pop(-2)
myshapeout = deepcopy(myshape)
myshapeout.pop(-2)
myshapeout[-1] = self._num_units
if self.strides is not None:
if len(myshapeout[1:-1]) != len(self.strides):
raise Exception(
"stride shape should match myshapeout[1:-1]! strides: {}, myshape: {}"
.format(self.strides, myshapeout))
myshapeout[1:-1] = [
int(np.round((myshapeout[1 + si]) / self.strides[si]))
for si in range(len(myshapeout) - 2)
]
self.myshapes = (myshapein, myshapeout)
def __init__(self, data, target, dropout, kw):
super(MDGRUClassificationWithGeneralizedDiceLoss, self).__init__(data, target, dropout, kw)
self.dice_loss_label = argget(kw, "dice_loss_label", [])
self.dice_loss_weight = argget(kw, "dice_loss_weight", [])
self.dice_autoweighted = argget(kw, "dice_autoweighted", False)
self.logger = logging.getLogger('runner.model')
self.logger.debug('initialization MDGRUClassificationWithGeneralizedDiceLoss:')
self.logger.debug(f' self.dice_loss_label: {self.dice_loss_label}')
self.logger.debug(f' self.dice_loss_weight: {self.dice_loss_weight}')
self.logger.debug(f' self.dice_autoweighted: {self.dice_autoweighted}')
if len(self.dice_loss_label) != len(self.dice_loss_weight) and not self.dice_autoweighted:
raise Exception("dice_loss_label and dice_loss_weight need to be of the same length")
def __init__(self, modelcls, datacls, kw):
"""
Handler for the evaluation of model defined in modelcls using data coming from datacls.
Parameters
----------
modelcls : cls
Python class defining the model to evaluate
datacls : cls
Python class implementing the data loading and storing
"""
self.origargs = copy.copy(kw)
eval_kw, kw = compile_arguments(SupervisedEvaluation, kw, transitive=False)
for k, v in eval_kw.items():
setattr(self, k, v)
self.w = self.windowsize
self.p = self.padding
self.use_tensorboard = False
# self.dropout_rate = argget(kw, "dropout_rate", 0.5)
self.current_epoch = 0
self.current_iteration = 0
# create datasets for training, validation and testing:
locs = [[None, l] if l is None or len(l) > 1 else [os.path.join(self.datapath, l[0]), None] for l in
[self.locationtraining, self.locationvalidation, self.locationtesting]]
paramstraining = [self.w, self.p] + locs[0]
paramsvalidation = [self.windowsizevalidation if self.windowsizevalidation is not None else self.w,
self.paddingvalidation if self.paddingvalidation is not None else self.p] + locs[1]
paramstesting = [self.windowsizetesting if self.windowsizetesting is not None else self.w,
self.paddingtesting if self.paddingtesting is not None else self.p] + locs[2]
kwdata, kw = compile_arguments(datacls, kw, True, keep_entries=True)
kwcopy = copy.copy(kwdata)
kwcopy['nclasses'] = self.output_dims
kwcopy['batch_size'] = self.batch_size
self.trdc = datacls(*paramstraining, kw=copy.copy(kwcopy))
testkw = copy.copy(kwcopy)
testkw['batch_size'] = testkw['batch_size'] if not self.testbatchsize else self.testbatchsize
valkw = copy.copy(testkw)
testkw['ignore_missing_mask'] = True
self.tedc = datacls(*paramstesting, kw=testkw)
self.valdc = datacls(*paramsvalidation, kw=valkw)
self.currit = 0
self.show_dice = argget(kw, "show_dice", not self.show_f1)
self.binary_evaluation = self.show_dice or self.show_f1 or self.show_f05 or self.show_f2
self.estimatefilename = argget(kw, "estimatefilename", "estimate")
self.gpu = argget(kw, "gpus", [0])
self.get_train_session = lambda: self
self.get_test_session = lambda: self
def __init__(self, data, dropout, kw):
super(Model, self).__init__()
model_kw, kw = compile_arguments(Model, kw, transitive=False)
for k, v in model_kw.items():
setattr(self, k, v)
th.cuda.manual_seed_all(self.model_seed)
th.manual_seed(self.model_seed)
self.origargs = copy.copy(kw)
if argget(kw, "whiten", False):
print('parameter whiten not supported with pytorch version')
# self.data = batch_norm(data, "bn", self.training, m=32)
else:
self.data = data
pass
self.dimensions = argget(kw, "dimensions", None)
def __init__(self, data, target, dropout, kw):
self.origargs = copy.copy(kw)
model_kw, kw = compile_arguments(Model, kw, transitive=False)
for k, v in model_kw.items():
setattr(self, k, v)
# self.model_seed = argget(kw, 'model_seed', 12345678)
tf.set_random_seed(self.model_seed)
super(Model, self).__init__(data, target, dropout, kw)
self.training = argget(kw, "training", tf.constant(True))
self.global_step = tf.Variable(0, name="global_step", trainable=False)
self.use_tensorboard = argget(kw, "use_tensorboard", True)
#
# if argget(kw, "whiten", False):
# self.data = batch_norm(data, "bn", self.training, m=32)
# else:
self.data = data
# pass
self.dimensions = argget(kw, "dimensions", None)
def __init__(self, num_spatial_dims, dropout, num_input, num_hidden,
num_output, kw):
super(MDGRUBlock, self).__init__()
mdrnn_net_kw, kw = compile_arguments(MDGRUBlock, kw, transitive=False)
for k, v in mdrnn_net_kw.items():
setattr(self, k, v)
self.mdrnn_kw, kw = compile_arguments(MDRNN, kw, transitive=True)
self.crnn_kw, kw = compile_arguments(self.mdrnn_kw['crnn_class'],
kw,
transitive=True)
spatial_dimensions = argget(kw, "dimensions", None)
if spatial_dimensions is None:
spatial_dimensions = [i for i in range(num_spatial_dims)]
mdrnn_kw = {}
mdrnn_kw.update(self.mdrnn_kw)
mdrnn_kw.update(self.crnn_kw)
mdrnn_kw.update(kw)
mdrnn_kw["num_hidden"] = num_hidden
mdrnn_kw["num_input"] = num_input
mdrnn_kw["name"] = "mdgru"
model = [MDRNN(dropout, spatial_dimensions, mdrnn_kw)]
if num_spatial_dims == 2:
convop = th.nn.Conv2d
kernel = [1, 1]
elif num_spatial_dims == 3:
convop = th.nn.Conv3d
kernel = [1, 1, 1]
else:
raise Exception(
'pytorch cannot handle more than 3 dimensions for convolution')
if num_output is not None:
model += [convop(num_hidden, num_output, kernel)]
if not self.noactivation:
model += [self.vwfc_activation()]
self.model = th.nn.Sequential(*model)
def __init__(self, data, dropout, kw):
super(ReconstructionModel, self).__init__(data, dropout, None, kw)
self.dropout = dropout
self.learning_rate = argget(kw, "learning_rate", 0.001)
self.nclasses = argget(kw, "nclasses", 2)
def __init__(self, data, dropout, kw):
super(ClassificationModel, self).__init__(data, dropout, kw)
self.dropout = dropout
self.learning_rate = argget(kw, "learning_rate", 1)
self.momentum = argget(kw, "momentum", 0.9)
self.nclasses = argget(kw, "nclasses", 2)
def remove_example_nifti_data(**kw):
testdatadir = argget(kw, "testdatadir", ".")
datafolder = argget(kw, "datafolder", "nifti")
shutil.rmtree(os.path.join(testdatadir, datafolder))
def mdgru_bb(self, inp, dropout, num_hidden, num_output, noactivation=False,
name=None, **kw):
"""Convenience function to combine a MDRNN layer with a voxel-wise fully connected layer.
:param inp: input data
:param dropout: dropout rate
:param num_hidden: number of hidden units, output units of the MDRNN
:param num_output: number of output units of the voxel-wise fully connected layer
(Can be None -> no voxel-wise fully connected layer)
:param noactivation: Flag to disable activation of voxel-wise fully connected layer
:param name: Name for this particular MDRNN + vw fully connected layer
:param kw: Arguments for MDRNN and the vw fully connected layer (can override this class' attributes)
:return: Output of the voxelwise fully connected layer and MDRNN mix
"""
dimensions = argget(kw, "dimensions", None)
if dimensions is None:
dimensions = [i + 1 for i, v in enumerate(inp.get_shape()[1:-1]) if v > 1]
mdrnn_kw = {}
mdrnn_kw.update(self.mdrnn_kw)
mdrnn_kw.update(self.crnn_kw)
mdrnn_kw.update(kw)
add_e_bn = argget(kw, "add_e_bn", self.add_e_bn)
resmdgru = argget(kw, "resmdgru", self.resmdgru)
mdrnn_kw["num_hidden"] = num_hidden
mdrnn_kw["name"] = "mdgru"
with tf.variable_scope(name):
mdgruclass = MDRNN(inp, dropout, dimensions, mdrnn_kw)
mdgru = mdgruclass()
if num_output is not None:
mdgruinnershape = mdgru.get_shape()[1:-1].as_list()
doreshape = False
if len(mdgruinnershape) >= 3:
newshape = [-1, np.prod(mdgruinnershape), mdgru.get_shape().as_list()[-1]]
mdgru = tf.reshape(mdgru, newshape)
doreshape = True
num_input = mdgru.get_shape().as_list()[-1]
filtershape = [1 for _ in mdgru.get_shape()[1:-1]] + [num_input, num_output]
numelem = (num_output + num_input) / 2
uniform = False
if self.vwfc_activation in [tf.nn.elu, tf.nn.relu]:
numelem = (num_input) / 2
uniform = False
W = tf.get_variable(
"W", filtershape, dtype=tf.float32, initializer=get_modified_xavier_method(numelem, uniform))
b = tf.get_variable("b", [num_output], initializer=tf.constant_initializer(0))
mdgru = tf.nn.convolution(mdgru, W, padding="SAME")
if resmdgru:
if doreshape:
inp = tf.reshape(inp,
[-1, np.prod(inp.get_shape()[1:-1].as_list()), inp.get_shape().as_list()[-1]])
resW = tf.get_variable("resW",
[1 for _ in inp.get_shape().as_list()[1:-1]] + [
inp.get_shape().as_list()[-1], num_output],
dtype=tf.float32, initializer=get_modified_xavier_method(num_output, False))
mdgru = tf.nn.convolution(inp, resW, padding="SAME") + mdgru
if add_e_bn:
mdgru = batch_norm(mdgru, "bne", mdgruclass.istraining, bias=False, m=mdgruclass.min_mini_batch)
mdgru = mdgru + b
if doreshape:
mdgru = tf.reshape(mdgru, [-1] + mdgruinnershape + [mdgru.get_shape().as_list()[-1]])
if noactivation:
return mdgru
else:
return self.vwfc_activation(mdgru)
def __init__(self, evaluationinstance, **kw):
"""
Parameters
----------
evaluationinstance : instance of an evaluation class
Will be used to call train and test routines on.
"""
self.origargs = copy.deepcopy(kw)
runner_kw, kw = compile_arguments(Runner, kw, transitive=False)
for k, v in runner_kw.items():
setattr(self, k, v)
if self.save_each is None:
self.save_each = self.test_each
if self.notifyme:
try:
# import json
data = json.load(open('../config.json'))
nm = dict(chat_id=data['chat_id'], token=data['token'])
try:
nm['chat_id'] = int(self.notifyme)
except Exception:
pass
finally:
self.notifyme = nm
except:
# we give up
print('notifyme id not understood')
# prelogging:
# experiments = argget(kw, 'experimentloc', os.path.expanduser('~/experiments'))
self.runfile = [
f[1] for f in inspect.stack() if re.search("RUN.*\.py", f[1])
][0]
if self.optionname is None:
self.optionname = [
hashlib.sha256(json.dumps(
self.fullparameters).encode('utf8')).hexdigest()
]
elif not isinstance(self.optionname, list):
self.optionname = [self.optionname]
self.estimatefilenames = self.optionname
if isinstance(self.optionname, list):
pf = "-".join(self.optionname)
if len(pf) > 40:
pf = pf[:39] + "..."
else:
pf = self.optionname
self.experiments_postfix = '_' + pf
experiments_nots = os.path.join(
self.experimentloc,
'{}'.format(self.runfile[self.runfile.index("RUN_") + 4:-3] +
self.experiments_postfix))
self.experiments = os.path.join(experiments_nots,
str(int(time.time())))
self.cachefolder = os.path.join(self.experiments, 'cache')
os.makedirs(self.cachefolder)
# Add Logging.FileHandler (StreamHandler was added already in RUN_mdgru.py)
loggers = [
logging.getLogger(n)
for n in ['model', 'eval', 'runner', 'helper', 'data']
]
formatter = logging.Formatter(
'%(asctime)s %(name)s\t%(levelname)s:\t%(message)s')
logfile = argget(kw, 'logfile',
os.path.join(self.cachefolder, 'log.txt'))
fh = logging.FileHandler(logfile)
fh.setLevel(argget(kw, 'logfileloglvl', logging.DEBUG))
fh.setFormatter(formatter)
# ch = logging.StreamHandler()
# ch.setFormatter(formatter)
# ch.setLevel(argget(kw, 'loglvl', logging.DEBUG))
for logger in loggers:
logger.setLevel(logging.DEBUG)
# logger.addHandler(ch)
logger.addHandler(fh)
for k in self.origargs:
logging.getLogger('runner').info('args runner {}:{}'.format(
k, self.origargs[k]))
self.ev = evaluationinstance
for k in self.ev.origargs:
logging.getLogger('runner').info(
'args eval/data/model {}:{}'.format(k, self.ev.origargs[k]))
# for k in self.ev.trdc.origargs:
# logging.getLogger('data').info(' trdc arg {}:{}'.format(k, self.ev.trdc.origargs[k]))
# for k in self.ev.tedc.origargs:
# logging.getLogger('data').info(' tedc arg {}:{}'.format(k, self.ev.tedc.origargs[k]))
# for k in self.ev.valdc.origargs:
# logging.getLogger('data').info('valdc arg {}:{}'.format(k, self.ev.valdc.origargs[k]))
# for k in self.ev.model.origargs:
# logging.getLogger('model').info('arg {}:{}'.format(k, self.ev.model.origargs[k]))
if self.only_train or (self.ev.trdc == self.ev.tedc
and self.ev.valdc != self.ev.trdc):
self.episodes = ['train']
elif self.only_test or (self.ev.trdc == self.ev.tedc
and self.ev.valdc == self.ev.tedc):
self.episodes = ['evaluate']
else:
self.episodes = ['train', 'evaluate']
# self.episodes = argget(kw, 'episodes', ['train', 'evaluate'])
# self.epochs = argget(kw, 'epochs', 1)
if self.iterations is None:
self.its_per_epoch = self.ev.trdc.get_data_dims(
)[0] // self.ev.batch_size
else:
self.epochs = 0
self.its_per_epoch = self.iterations
# self.its_per_epoch = argget(kw, 'its_per_epoch', self.ev.trdc.get_data_dims()[0] // self.ev.batch_size)
# self.checkpointfiles = argget(kw, 'checkpointfiles', None)
self.estimatefilenames = self.optionname #argget(kw, 'estimatefilenames', None)
if isinstance(self.checkpointfiles, list):
if 'train' in self.episodes and len(self.checkpointfiles) > 1:
logging.getLogger('runner').error(
'Multiple checkpoints are only allowed if only testing is performed.'
)
exit(1)
else:
self.checkpointfiles = [self.checkpointfiles]
# if not isinstance(self.estimatefilenames, list):
# self.estimatefilenames = [self.estimatefilenames]
if len(self.checkpointfiles) != len(self.estimatefilenames):
if len(self.estimatefilenames) != 1:
logging.getLogger('runner').error(
'Optionnames must match number of checkpoint files or have length 1!'
)
exit(1)
else:
self.estimatefilenames = [
self.estimatefilenames[0] +
"-{}-{}".format(i, os.path.basename(c))
for i, c in enumerate(self.checkpointfiles)
]
self.plotfolder = os.path.join(self.experiments, 'plot')
self.plot_scaling = argget(kw, 'plot_scaling', 1e-8)
# self.display_each = argget(kw, 'display_each', 100)
# self.test_each = argget(kw, 'test_each', 100)
# self.save_each = argget(kw, 'save_each', self.test_each)
# self.plot_each = argget(kw, 'plot_each', self.test_each)
# self.test_size = argget(kw, 'test_size', 1) # batch_size for tests
# self.test_iters = argget(kw, 'test_iters', 1)
self._test_pick_iteration = self.test_each - 1 if not self.test_first else 0
# self._test_pick_iteration = argget(kw, 'test_first', ifset=0, default=self.test_each - 1)
# self.perform_full_image_validation = argget(kw, 'perform_full_image_validation', 1)
# self.save_validation_results = argget(kw, 'show_testing_results', False)
force_symlink(self.experiments, os.path.join(experiments_nots,
"latest"))
os.makedirs(self.plotfolder)
# self.notifyme = argget(kw, 'notifyme', False)
# self.results_to_csv = argget(kw, 'results_to_csv', False)
self.train_losses = []
self.test_losses = []
self.val_losses = []
# remove full parameters since it would not be an ignored parameter and confuse us
# kw.pop('fullparameters')
if kw:
logging.getLogger('runner').warning(
'the following args were ignored: {}'.format(kw))
def __init__(self, w, p, location=None, tps=None, kw={}):
"""
Parameters
----------
w : list
subvolume/patchsize
p : list
amount of padding per dimension.
location : str, optional
Root folder where samples defined by featurefiles and maskfiles lie. Needs to be provided if tps is not.
tps : list, optional
List of locations or samples defined by featurefiles and maskfiles. Needs to be provided if location is not.
"""
super(GridDataCollection, self).__init__(kw)
self.origargs.update({"location": location, "tps": tps})
self.w = np.ndarray.tolist(w) if not isinstance(w, list) else w
self.p = p
data_kw, kw = compile_arguments(GridDataCollection, kw, transitive=False)
for k, v in data_kw.items():
setattr(self, k, v)
if (self.w) != 3:
self.correct_orientation = False
if tps is not None:
self.tps = []
[self.tps.extend(DataCollection.get_all_tps(t, self.featurefiles,
self.maskfiles if not self.ignore_missing_mask else [])) for t
in tps]
elif location is not None:
if callable(location):
self.tps = [location]
else:
self.tps = DataCollection.get_all_tps(location, self.featurefiles,
self.maskfiles if not self.ignore_missing_mask else [])
if len(self.tps) == 0:
raise Exception(
'no timepoints at location {} containing both {} and {}'.format(location, self.maskfiles,
self.featurefiles))
else:
raise Exception('either tps or location has to be set')
if len(self.tps) == 0:
raise Exception('there were no timepoints provided and location was not set')
def oneorn(paramname):
t = getattr(self, paramname)
if len(t) == 1:
setattr(self, paramname, t * len(self.w))
elif len(t) == len(self.w) or len(t) == 0:
return
else:
raise Exception('Parameter {} needs to have the same amount of entries as windowsize'.format(paramname))
oneorn('p')
oneorn('subtractGaussSigma')
oneorn('deform')
oneorn('deformSigma')
oneorn('mirror')
oneorn('scaling')
oneorn('shift')
oneorn('presize_for_normalization')
self.deformrandomstate = np.random.RandomState(self.deformseed)
if self.choose_mask_at_random:
self.random_mask_state = np.random.RandomState(argget(kw, 'randommaskseed', 1337))
self.imagedict = {}
self.numoffeatures = argget(kw, 'numoffeatures', len(self._get_features_and_masks(self.tps[0])[0]))
self.sample_counter = 0
if not self.lazy and self.preloadall:
self.preload_all()
def __init__(self,
inputarr,
dropout,
dimensions=None,
layers=1,
num_hidden=100,
name="mdgru",
**kw):
self.inputarr = inputarr
self.generator = argget(kw, "generator", False)
self.add_x_bn = argget(kw, "bnx", False)
self.add_h_bn = argget(kw, "bnh", False)
self.add_a_bn = argget(kw, "bna", False)
self.form = argget(kw, "form", "NDHWC")
self.istraining = argget(kw, "istraining", tf.constant(True))
if dimensions is None:
self.dimensions = [
x + 1 for x in range(len(inputarr.get_shape()[1:-1]))
]
else:
self.dimensions = dimensions
self.layers = layers
self.num_hidden = num_hidden
self.name = name
self.dropout = dropout
self.use_dropconnectx = argget(kw, "use_dropconnectx", True)
self.use_dropconnecth = argget(kw, "use_dropconnecth", False)
self.use_bernoulli = argget(kw, "use_bernoulli_dropconnect", False)
self.mask_padding = argget(kw, "maskpadding", None)
self.m = argget(kw, "min_mini_batch", None)
self.favor_speed_over_memory = argget(kw, "favor_speed_over_memory",
False)
self.filter_sizes = argget(kw, "filter_sizes", [7, 7, 7])
if any([self.add_x_bn, self.add_h_bn, self.add_a_bn]):
raise Exception("bn not allowed for caffemdgru")
def create_example_nifti_data(**kw):
shape = argget(kw, "shape", (100, 100, 40))
border_edges = argget(kw, "border_edges", [[30, 70], [30, 70], [10, 30]])
edge_variation = argget(kw, "edge_variation", (15, 15, 8))
rater_variation = argget(kw, "rater_variation", (2, 2, 2))
patients = argget(kw, "patients", [
"ruedi", "hans", "eva", "micha", "joerg", "maya", "frieda", "anna",
"chelsea", "flynn"
])
patient_belongs_to = argget(kw, "patient_belongs_to", [
"train", "train", "train", "train", "train", "val", "val", "test",
"test", "test"
])
testdatadir = argget(kw, "testdatadir", ".")
affine = np.zeros((4, 4))
affine[0, 2] = 1
affine[1, 0] = 1
affine[2, 1] = 1
affine[3, 3] = 1
datafolder = argget(kw, "datafolder", "nifti")
testdatadirnifti = os.path.join(testdatadir, datafolder)
if os.path.exists(testdatadirnifti):
print(
'Files have already been generated. If something is amiss, delete the nifti folder and start again!'
)
return
for f, pat in zip(patient_belongs_to, patients):
patdir = os.path.join(os.path.join(testdatadirnifti, f), pat)
if not os.path.exists(patdir):
os.makedirs(patdir)
gt_mask = np.zeros(shape)
gt_borders = [[
x[0] + (np.random.random() * 2 - 1) * e,
x[1] + (np.random.random() * 2 - 1) * e
] for x, e in zip(border_edges, edge_variation)]
gt_borders = np.uint32(gt_borders)
gt_mask[gt_borders[0][0]:gt_borders[0][1],
gt_borders[1][0]:gt_borders[1][1],
gt_borders[2][0]:gt_borders[2][1]] = 1
for file in ["flair", "mprage", "t2", "pd"]:
myfile = os.path.join(patdir, file + ".nii.gz")
if not os.path.exists(os.path.join(patdir, file + ".nii.gz")):
dat = np.float32(np.random.random(shape)) * np.random.randint(
200, 2400) + np.random.randint(200, 800)
dat += gt_mask * np.random.random(shape) * np.random.randint(
200, 400)
nib.save(nib.Nifti1Image(dat, affine), myfile)
for file in ["mask1", "mask2"]:
myfile = os.path.join(patdir, file + ".nii.gz")
if not os.path.exists(os.path.join(patdir, file + ".nii.gz")):
dat = np.zeros(shape, dtype=np.uint8)
rater_borders = [[
x[0] + (np.random.random() * 2 - 1) * e,
x[1] + (np.random.random() * 2 - 1) * e
] for x, e in zip(gt_borders, rater_variation)]
rater_borders = np.uint32(rater_borders)
dat[rater_borders[0][0]:rater_borders[0][1],
rater_borders[1][0]:rater_borders[1][1],
rater_borders[2][0]:rater_borders[2][1]] = 1
nib.save(nib.Nifti1Image(dat, affine), myfile)
