def find_by_regression(modelfile, input_npy_file):
print('running')
resized_npy, ori_size = BoundryFinder._resize_npy(input_npy_file)
net_t = ModelLoader.load("FindBoundaryRegressioNet64128128")
net_t = torch.nn.DataParallel(net_t)
net_t = net_t.eval()
state = torch.load(modelfile)
# state = torch.load('/home/modelout/save_xyt/20180313_21/FindBoundaryRegression-Test/model/400_net_params.pkl')
# data_sign = 'clean64128128.npy'
# data_raw_sign = 'clean.npy'
net_t.load_state_dict(state)
net_t = torch.nn.DataParallel(net_t).cuda()
img = resized_npy
imgc = img.copy()
imgc[imgc > 500] = 500
imgc[imgc < -300] = -300
imgctmp = np.reshape(imgc, (-1, imgc.shape[0]))
imgc_mean = np.mean(imgctmp)
imgc_std = np.std(imgctmp)
newimg = (imgc - imgc_mean) / imgc_std
newimg = newimg.astype('float32')
newimgth = torch.autograd.Variable(torch.from_numpy(
newimg[np.newaxis, np.newaxis]).cuda(),
volatile=True)
output = net_t(newimgth)
outputc = output.view(-1)
outputc_np = outputc.data.cpu().numpy()
pt1 = outputc_np[0:3] * ori_size
pt2 = outputc_np[3:6] * ori_size
pt1 = pt1 - BUFFER
pt1[pt1 < 0] = 0
pt2 = pt2 + BUFFER
index = 0
for i in pt2:
if i > ori_size[index]:
pt2[index] = ori_size[index]
index += 1
pt1 = pt1.astype(int)
pt2 = pt2.astype(int)
print('DONE!')
return pt1, pt2
def __call__(self, parser, args, values, option_string=None):
data = ModelLoader.model_info(name=values[0])
if data is not None:
left_col_width = max([len(t[0]) for t in data])
for (k, v) in data:
if not isinstance(v, list):
print("{1:>{0}}: {2}".format(left_col_width, k, v))
else:
if (len(v) <= 1):
continue
print("{1:>{0}}: {2}".format(left_col_width, k, v[0]))
for i in range(1, len(v)):
print("{1:>{0}} {2}".format(left_col_width, "", v[i]))
exit()
parser.add_argument('--no_segmentation_images', action='store_true', default=False, help='Reduce output files to minimum')
args = parser.parse_args()
# Title
print("RootNav 2.0")
sys.stdout.flush()
# Input and output directory are required
if not args.input_dir or not args.output_dir:
parser.print_help()
exit()
# Check cuda configuration and notify if cuda is unavailable but they are trying to use it
if not torch.cuda.is_available() and not args.no_cuda:
print ("Cuda is not available, switching to CPU")
use_cuda = torch.cuda.is_available() and not args.no_cuda
# Check CRF flag
use_crf = not args.no_crf
# Load the model
try:
model_data = ModelLoader.get_model(args.model, gpu=use_cuda)
except Exception as ex:
print (ex)
exit()
# Process
run_rootnav(model_data, use_cuda, use_crf, args.input_dir, args.output_dir, args.no_segmentation_images)
def __call__(self, parser, args, values, option_string=None):
table_data = [("Model", "Description")] + [
(name, desc) for name, desc in ModelLoader.list_models(True)
]
print_table(table_data)
exit()
def prepare(config):
if 'hardmining' in config.prepare and config.prepare['hardmining']:
from datasets import myDataset2 as myDataset
else:
from datasets import myDataset
from datasets import myDataset as myDataset_val
env_utils.setEnvironment(config)
if config.debug:
model = ModelLoader.load(config.net["model"], config=config, abn=1)
elif config.jit:
model = ModelLoader.load(config.net["model"], config=config, abn=0)
else:
model = ModelLoader.load(config.net["model"], config=config)
loss = LossLoader.load(config.net["rpnloss"], config)
em_names = config.net['em']
em_list = []
for ems in em_names:
em_list.append(LossLoader.load(ems, config))
netio = netIOer(config)
if config.half:
model = model.half()
model = BN_convert_float(model)
if config.net["load_weight"] != '':
model, config = netio.load_file(model, config.net["load_weight"])
# optimizer = optim.SGD(model.parameters(), lr= config.train['lr_arg'], momentum=0.9,
# weight_decay=config.train['weight_decay'])
model = model.cuda()
if config.jit:
netio.trace(model)
sys.exit()
loss = loss.cuda()
warp = warpLoss(model, loss, config.prepare['margin'])
if not config.debug:
warp = DataParallel(warp)
trainer = Trainer(warp, config, netio, emlist=em_list)
train_data = myDataset(config, 'train')
if config.valtrain:
val_data = myDataset_val(config, 'valtrain')
else:
val_data = myDataset_val(config, 'val')
print(config.augtype)
print(config.env['cpu_num'])
train_loader = DataLoader(train_data,
batch_size=config.train['batch_size'],
shuffle=True,
num_workers=config.env['cpu_num'],
drop_last=True,
pin_memory=True,
worker_init_fn=np.random.seed)
val_loader = DataLoader(val_data,
batch_size=1,
shuffle=False,
num_workers=5,
pin_memory=True,
collate_fn=lambda x: x)
return config, model, loss, warp, trainer, train_data, val_data, train_loader, val_loader
def train(model_name):
# Data parameters
#data_dir = r'C:\Users\Lorenz\Documents\Coding\data\jester_hand_gestures'
data_dir = r'/Users/benja/code/jester/data'
seq_length = 40
n_videos = {'train': 1000, 'validation': 100}
image_size = (50, 88)
# Training parameters
n_epochs = 50
batch_size = 8
steps_per_epoch = n_videos['train'] // batch_size
# Load data generators
data = CNN3DDataLoader(data_dir,
seq_length=seq_length,
n_videos=n_videos,
labels=labels_want)
train_gen = data.sequence_generator('train', batch_size, image_size)
validation_gen = data.sequence_generator('validation', batch_size,
image_size)
#optimizer = keras.optimizers.SGD(lr=0.1, momentum=0.9, decay= 1e-6, nesterov=True)
#Load model
optimizer = keras.optimizers.Adadelta()
ml = ModelLoader(data.n_labels,
data.seq_length,
model_name,
image_size=image_size,
optimizer=optimizer)
model = ml.model
#Define callbacks
checkpointer = ModelCheckpoint(filepath='model_name' +
'-{epoch:03d}-{loss:.3f}.hdf5',
verbose=1,
save_best_only=True)
tb = TensorBoard(log_dir='./models/logs')
early_stopper = EarlyStopping(patience=2)
csv_logger = CSVLogger('./models/logs/' + model_name + '-' + 'training-' + \
str(time.time()) + '.log')
callbacks = [tb, early_stopper, csv_logger, checkpointer]
# Training
print('Starting training')
history = model.fit_generator(
generator=train_gen,
steps_per_epoch=20,
#sample_per_epoch= 200,
epochs=n_epochs,
verbose=1,
callbacks=callbacks,
validation_data=validation_gen,
validation_steps=10,
)
model.save('./my_model.h5')
save_history(history, "c3d")
def _seg(self, net_name, model_file):
self.cut_npy()
print("running")
net_t = ModelLoader.load(net_name)
net_t = torch.nn.DataParallel(net_t)
net_t = net_t.eval()
state = torch.load(model_file)
cropsize = np.array([64, 320, 320])
stride_z = 64
net_t.load_state_dict(state)
net_t = torch.nn.DataParallel(net_t).cuda()
sigmoid = torch.nn.Sigmoid()
img = self.modified_npy
img = (img + 300.0) / 800.0
img[img > 1] = 1.0
img[img < 0] = 0.0
pred = img.copy()
pred[pred != 0] = 0
lpt1 = self.pt1
lpt2 = self.pt2
expend = np.array([10, 10, 10])
lpt1, lpt2 = self._expandPt(lpt1, lpt2, expend, img.shape)
num = int(img.shape[0] / stride_z)
if num != img.shape[0] / stride_z:
num = num + 1
for i in range(num):
lpt2_e = lpt2.copy()
lpt2_e[1] = lpt1[1] + cropsize[1]
lpt2_e[2] = lpt1[2] + cropsize[2]
if lpt2_e[1] > img.shape[1]:
lpt2_e[1] = img.shape[1]
lpt1[1] = lpt2_e[1] - cropsize[1]
if lpt2_e[2] > img.shape[2]:
lpt2_e[2] = img.shape[2]
lpt1[2] = lpt2_e[2] - cropsize[2]
start_z = lpt1[0] + stride_z * i
end_z = lpt1[0] + stride_z * (i + 1)
if end_z > img.shape[0]:
end_z = img.shape[0]
start_z = end_z - cropsize[0]
imgc = img[start_z:end_z, lpt1[1]:lpt2_e[1], lpt1[2]:lpt2_e[2]]
print("imshape:", imgc.shape)
imgc = imgc.astype("float32")
imgcth = torch.autograd.Variable(torch.from_numpy(
imgc[np.newaxis, np.newaxis]).cuda(),
volatile=True)
output = net_t(imgcth)
Sigmoidout = sigmoid(output)
prob5_np = Sigmoidout.data.cpu().numpy()
prob_np = prob5_np[0][0]
pred[start_z:end_z, lpt1[1]:lpt2_e[1],
lpt1[2]:lpt2_e[2]] += prob_np
print("pred", pred.shape)
pred[pred > 0.15] = 1
pred[pred <= 0.15] = 0
pred = self._cleanNoisePred(pred)
return pred