def launch(data_root, output_path, training_iters, epochs, restore, layers, features_root):
generator = Generator(572, data_root)
data, label = generator(1)
weights = None#(1/3) / (label.sum(axis=2).sum(axis=1).sum(axis=0) / data.size)
net = unet.Unet(channels=generator.channels,
n_class=generator.n_class,
layers=layers,
features_root=features_root,
add_regularizers=True,
class_weights=weights,
# filter_size=5
)
path = output_path if restore else create_training_path(output_path)
# trainer = unet.Trainer(net, optimizer="momentum", opt_kwargs=dict(momentum=0.2))
trainer = unet.Trainer(net, optimizer="adam", opt_kwargs=dict(beta1=0.91))
path = trainer.train(generator, path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
prediction = net.predict(path, data)
print("Testing error rate: {:.2f}%".format(unet.error_rate(prediction, util.crop_to_shape(label, prediction.shape))))
# import numpy as np
# np.save("prediction", prediction[0, ..., 1])
img = util.combine_img_prediction(data, label, prediction)
util.save_image(img, "prediction.jpg")
def load_and_predict(data):
"""
Return UNet predicted output and SEEK's sum_threshold output (check RFI
mitigation page in SEEK docs)
"""
# Define Unet
unet = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=3,
features_root=64,
cost_kwargs=dict(regularizer=0.001),
)
# Path to cpkt file of trained Unet
path = "./unet_trained_bgs_example_data/model.cpkt"
# Predict using Unet
data_provider = DataProvider(600, data)
x_test, y_test = data_provider(1)
unet_predict = unet.predict(path, data)
fig, ax = plt.subplots(1, 3, figsize=(12, 4))
ax[0].imshow(x_test[0, ..., 0], aspect="auto")
ax[1].imshow(y_test[j, ..., 1], aspect="auto")
ax[2].imshow(unet_predict[0, ..., 1], aspect="auto", cmap="gray")
fig.savefig("pred" + str(1) + ".png")
# Predict using SEEK's sum_threshold
with h5py.File("data", "r") as fp:
timeord = fp["P/Phase1"].value
def runUnet(data, model, chan, classes, layers, features):
message = request.get_json(force=True)
img = decode(data["data"])
img = np.array(img, np.float32)
net = unet.Unet(channels=chan,
n_class=classes,
layers=layers,
features_root=features)
print(img)
ny = img.shape[0]
nx = img.shape[1]
img = img.reshape(1, ny, nx, 1)
img -= np.amin(img)
img /= np.amax(img)
prediction = net.predict(model, img)
prediction = util.expand_to_shape(prediction, [1, ny, nx, classes])
mask = prediction[0, ..., 1] > 0.1
data["data"] = encode(mask)
print(data)
return data
def train(args):
# preparing data loading
data_provider = image_util.ImageDataProvider(args.data_dir,
n_class=args.classes,
class_colors=[0, 255, 127])
# setup & training
net = unet.Unet(layers=args.layers,
features_root=args.features_root,
channels=args.channels,
n_class=args.classes)
trainer = unet.Trainer(net)
total_parameters = 0
for variable in tf.trainable_variables():
# shape is an array of tf.Dimension
shape = variable.get_shape()
variable_parameters = 1
for dim in shape:
variable_parameters *= dim.value
total_parameters += variable_parameters
print("Total number of parameters:{0}".format(total_parameters))
trainer.train(data_provider,
args.output_path,
training_iters=args.training_iters,
epochs=args.num_epochs,
write_graph=args.write_graph,
restore=args.restore)
def launch(data_root, output_path, training_iters, epochs, restore, layers, features_root):
print("Using data from: %s"%data_root)
data_provider = DataProvider(600, glob.glob(data_root+"/*"))
net = unet.Unet(channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
add_regularizers=True,
# filter_size=5
)
path = output_path if restore else create_training_path(output_path)
trainer = unet.Trainer(net, optimizer="momentum", opt_kwargs=dict(momentum=0.2))
path = trainer.train(data_provider, path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
x_test, y_test = data_provider(1)
prediction = net.predict(path, x_test)
print("Testing error rate: {:.2f}%".format(unet.error_rate(prediction, util.crop_to_shape(y_test, prediction.shape))))
# import numpy as np
# np.save("prediction", prediction[0, ..., 1])
img = util.combine_img_prediction(x_test, y_test, prediction)
util.save_image(img, "prediction.jpg")
def test(model_dir, dataset_csv, working_dir, force=False, supervisely=False):
# create folder name
output_dir = os.path.join(
working_dir, s.stages[5], 'M' + os.path.basename(model_dir) + 'D' +
os.path.splitext(os.path.basename(dataset_csv))[0])
# only retest if necessary
if not os.path.exists(output_dir) or force:
# delete existing
if force and os.path.exists(output_dir):
try:
shutil.rmtree(output_dir)
except Exception as e:
print(e)
# make directory
os.makedirs(output_dir)
net = unet.Unet(
channels=s.network['channels'],
n_class=s.network['classes'],
layers=s.network['layers'],
features_root=s.network['features_root'],
cost_kwargs=dict(class_weights=s.network['class_weights']))
# Run prediction
net.predictAll(model_path=os.path.join(model_dir, 'model.cpkt'),
dataset_path=dataset_csv,
output_dir=output_dir,
roles=['test'],
supervisely=supervisely) # supervisely is added
else:
print(os.path.basename(output_dir), ' already exists. Skipping.')
def launch(data_root, output_path, training_iters, epochs, restore, layers,
features_root):
print("Using data from: %s" % data_root)
data_provider = ultrasound_util.DataProvider(data_root + "/*.tif",
a_min=0,
a_max=210)
net = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
cost="dice_coefficient",
)
path = output_path if restore else create_training_path(output_path)
trainer = unet.Trainer(net, norm_grads=True, optimizer="adam")
path = trainer.train(data_provider,
path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
x_test, y_test = data_provider(1)
prediction = net.predict(path, x_test)
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(y_test,
prediction.shape))))
def launch(data_root, output_path, training_iters, epochs, restore, layers,
features_root):
print("Using data from: %s" % data_root)
data_provider = DataProvider(600, glob.glob(data_root + "/*"))
net = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
cost_kwargs=dict(regularizer=0.001),
)
path = output_path if restore else create_training_path(output_path)
trainer = unet.Trainer(net,
optimizer="momentum",
opt_kwargs=dict(momentum=0.2))
path = trainer.train(data_provider,
path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
x_test, y_test = data_provider(1)
prediction = net.predict(path, x_test)
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(y_test,
prediction.shape))))
def launch(data_root, output_path, training_iters, epochs, restore, layers,
features_root):
data_provider = DataProvider(572, data_root)
data, label = data_provider(1)
weights = None #(1/3) / (label.sum(axis=2).sum(axis=1).sum(axis=0) / data.size)
net = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
cost_kwargs=dict(regularizer=0.001, class_weights=weights),
)
path = output_path if restore else util.create_training_path(output_path)
trainer = unet.Trainer(net, optimizer="adam", opt_kwargs=dict(beta1=0.91))
path = trainer.train(data_provider,
path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
prediction = net.predict(path, data)
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(label,
prediction.shape))))
def main():
# input training and test datasets
train_data = image_util.ImageDataProvider(
search_path='RoadDetection_Train_Images', n_class=2)
# instantiate U-net (best results: layers=5, feature_roots=64, batch_size=2, epochs=50, training_iters=64)
net = unet.Unet(layers=4,
n_class=train_data.n_class,
channels=train_data.channels,
features_root=48,
cost='dice_coefficient',
cost_kwargs={'regularizer': 0.01})
trainer = unet.Trainer(net,
batch_size=2,
verification_batch_size=4,
optimizer="momentum",
opt_kwargs=dict(momentum=0.5))
# path = trainer.train(data_provider=train_data, output_path="./unet_trained", training_iters=32, epochs=1, display_step=2)
trainer.train(data_provider=train_data,
output_path="./unet_trained",
training_iters=64,
epochs=50,
dropout=0.75,
display_step=2)
print('Process completed.')
def train(dataset_csv, working_dir, appendum='', force=False):
# create folder name
foldername = os.path.join(
working_dir, s.stages[4], '__'.join([
os.path.splitext(os.path.basename(dataset_csv))[0],
'ly' + str(s.network['layers']) + 'ftr' + str(s.network['features_root']) + appendum, ''
]))
# only retrain if necessary
if not os.path.exists(foldername) or force:
generator = image_util.ImageDataProvider(
dataset_path=dataset_csv,
roles=['train'],
shuffle_data=True,
a_min=None,
a_max=None,
n_class=s.network['classes'],
n_channels=s.network['channels']) # add all options and put shuffle data = True
net = unet.Unet(
channels=s.network['channels'],
n_class=s.network['classes'],
layers=s.network['layers'],
features_root=s.network['features_root'],
cost_kwargs=dict(class_weights=s.network['class_weights'])
)
trainer = unet.Trainer(net, optimizer=s.train['optimizer'], batch_size=s.train['batch_size'])
trainer.train(generator, foldername, training_iters=s.train['training_iters'], epochs=s.train['epochs'],
display_step=s.train['display_step'], dropout=s.train['dropout'],
restore=False, write_graph=True)
else:
print(os.path.basename(foldername), ' already exists. Skipping.')
def __init__(self, model_path="./unet_trained/model.ckpt"):
self.net = unet.Unet(channels=3, n_class=3, layers=3, features_root=16)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
self.net.restore(self.sess, model_path)
self.y_dummy = np.empty((1, 400, 288, 3))
def __init__(self, data_dir):
"""
data_directory : path like /home/rajat/nnproj/dataset/
includes the dataset folder with '/'
Initialize all your variables here
"""
self.path = data_dir
self.net = unet.Unet(layers=3, features_root=64, channels=1, n_class=2)
self.trainer = unet.Trainer(self.net)
self.count = 0
def __init__(self):
self.net = unet.Unet(channels=1, n_class=2, layers=5, features_root=16)
base = dirname(dirname(__file__))
self.imagepath = join(base, "testimages")
self.models = ["Fish", "Flower", "Gravel", "Sugar"]
self.testimages = os.listdir(self.imagepath)
self.nx = 350
self.ny = 525
self.mt = {"Fish": .5, "Gravel": .38263, "Flower": .4999, "Sugar": .39}
self.cropx = 196
self.cropy = 192
def predict(img):
if img.shape == 2:
img = img[np.newaxis, :, :, np.newaxis]
if img.shape == 3:
img = img[np.newaxis, :, :, :]
net = unet.Unet(channels=1, n_class=2, layers=4, features_root=64)
prediction = net.predict('./pre_trained/model.ckpt', img)
return prediction
def infer_test():
LAYERS = 3
pkl_fname = "data/preprocess/stage1_2_test_set.pkl"
with open(pkl_fname, "rb") as f:
ds = pickle.load(f)
net = unet.Unet(
channels=1,
n_class=2,
cost='cross_entropy',
layers=LAYERS,
features_root=64,
cost_kwargs=dict(regularizer=0.001),
)
net.load_weight("log/20180416/model.cpkt")
images_code = {}
for i, (image_id, value) in enumerate(ds.items()):
# image_part = value[0]['img']
# prob = infer_part(net, image_part)
#
# mask = prob > 0.5
# mask_ex = apply_morphology(mask)
# fig, ax = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(12,5))
# ax[0].imshow(image_part, aspect="auto")
# ax[1].imshow(mask_ex, aspect="auto")
# ax[2].imshow(mask, aspect="auto")
# ax[0].set_title("Input")
# ax[1].set_title("Ground truth")
# ax[2].set_title("Prediction")
# fig.tight_layout()
# plt.show()
# if i > 3:
# break
whole_image, whole_prob = infer_image(net, image_id, value)
code = prob_to_rles(whole_prob)
logging.info("code: %s", code)
images_code[image_id] = code
# if i > 5:
# break
# fig, ax = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(12,5))
# ax[0].imshow(whole_image, aspect="auto")
# ax[2].imshow(whole_pred, aspect="auto")
# ax[0].set_title("Input")
# ax[1].set_title("Ground truth")
# ax[2].set_title("Prediction")
# fig.tight_layout()
# plt.show()
return images_code
def main():
dp = DataProvider(batchSize=BATCH_SIZE, validationSize=VALIDATION_SIZE)
dp.readData()
print("DONE READING DATA")
# calculate num of iterations
iters = dp.getTrainSize() // BATCH_SIZE
# unet
net = unet.Unet(channels = 1, n_class = 2, layers = 3,\
features_root = 16, cost="cross_entropy", cost_kwargs={})
# # trainer
# options = {"momentum":0.2, "learning_rate":0.2,"decay_rate":0.95}
# trainer = unet.Trainer(net, optimizer="momentum",plotter = plot, opt_kwargs=options )
# # train model
# path = trainer.train(dp, OUTPUT_PATH,training_iters = iters,epochs=EPOCHS,\
# dropout=DROPOUT_KEEP_PROB, display_step = DISPLAY_STEP,restore = restore)
path = os.getcwd() + "/retinaModel/model.cpkt"
x_test, y_test = dp.getTestData(3, crop=False)
prediction = net.predict(path, x_test)
# # sanity check
# fig, ax = plt.subplots(3, 3)
# ax[0][0].imshow(x_test[0,:,:,0],cmap=plt.cm.gray)
# ax[0][1].imshow(y_test[0,:,:,1],cmap=plt.cm.gray)
# ax[0][2].imshow(np.argmax(prediction[0,...],axis =2),cmap=plt.cm.gray)
# ax[1][0].imshow(x_test[1,:,:,0],cmap=plt.cm.gray)
# ax[1][1].imshow(y_test[1,:,:,1],cmap=plt.cm.gray)
# ax[1][2].imshow(np.argmax(prediction[1,...],axis =2),cmap=plt.cm.gray)
# ax[2][0].imshow(x_test[2,:,:,0],cmap=plt.cm.gray)
# ax[2][1].imshow(y_test[2,:,:,1],cmap=plt.cm.gray)
# ax[2][2].imshow(np.argmax(prediction[2,...],axis =2),cmap=plt.cm.gray)
# plt.show()
# save test result as image
# check for path
if not os.path.lexists(OUTPUT_PATH):
os.makedirs(OUTPUT_PATH)
sampleSize = 3
img = util.combine_img_prediction(x_test[0:sampleSize,...], y_test[0:sampleSize,...]\
, prediction[0:sampleSize,...])
util.save_image(
img, "%s/%s.jpg" % (os.getcwd() + "/" + "testResults", "testSample"))
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(y_test,
prediction.shape))))
def train(gen):
net = unet.Unet(channels=gen.channels,
n_class=gen.n_class,
layers=5,
features_root=16)
trainer = unet.Trainer(net,
optimizer="momentum",
opt_kwargs=dict(momentum=0.2))
trainer.train(gen,
"./unet_trained/%s" % (gen.labelclass),
training_iters=32,
epochs=100,
display_step=2)
def launch(data_root,
roidictfile,
output_path,
training_iters,
epochs,
restore,
layers,
features_root,
val=None):
with open(roidictfile) as fh:
roidict = yaml.load(fh)
if val:
val_data_provider = ImageDataProvider(val, roidict)
data_provider = ImageDataProvider(data_root, roidict)
data, label = data_provider(1)
# make sure the labels are not flat
assert np.any(
np.asarray([label[-1, ..., nn].var()
for nn in range(label.shape[-1])]) > 0)
weights = None #(1/3) / (label.sum(axis=2).sum(axis=1).sum(axis=0) / data.size)
net = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
cost_kwargs=dict(regularizer=0.001, class_weights=weights),
)
path = output_path if restore else create_training_path(output_path)
trainer = unet.Trainer(net, optimizer="adam", opt_kwargs=dict(beta1=0.91))
path = trainer.train(data_provider,
path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore,
val_data_provider=val_data_provider)
prediction = net.predict(path, data)
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(label,
prediction.shape))))
def train():
net = unet.Unet(channels=1, n_class=2, layers=4, features_root=64)
trainer = unet.Trainer(net,
batch_size=8,
verification_batch_size=4,
optimizer='adam')
#data_provider = image_util.SimpleDataProvider(X_test, y_test)
path = trainer.train(X_test,
y_test,
X_test,
y_test,
'./pre_trained',
training_iters=32,
epochs=50,
dropout=0.5,
display_step=8,
restore=True) #restore = True
def run(sequence_dir, working_dir, force=False, model_dir=None):
multitime = os.path.basename(sequence_dir).split('_', maxsplit=1)[1]
camera = os.path.basename(sequence_dir).split('_', maxsplit=1)[0]
# If no model is provided, find one
if model_dir is None:
# Get appropriate model, has to have same camera and multitime
model_dirs = glob.glob(
os.path.join(working_dir, s.stages[4],
'cam1_intra_' + multitime + '*'))
else:
model_dirs = [model_dir]
for model_dir in model_dirs:
# Create output dir
output_dir = os.path.join(
working_dir, s.stages[6],
os.path.basename(model_dir) + os.path.basename(sequence_dir))
# only retest if necessary
if not os.path.exists(output_dir) or force:
# delete existing
if force and os.path.exists(output_dir):
try:
shutil.rmtree(output_dir)
except Exception as e:
print(e)
# make directory
os.makedirs(output_dir)
net = unet.Unet(
channels=s.network['channels'],
n_class=s.network['classes'],
layers=s.network['layers'],
features_root=s.network['features_root'],
cost_kwargs=dict(class_weights=s.network['class_weights']))
# Run prediction
net.predict_no_label(
model_path=os.path.join(model_dir, 'model.cpkt'),
images_dir=sequence_dir,
output_dir=output_dir,
)
else:
print(os.path.basename(output_dir), ' already exists. Skipping.')
def train(raw_path, label_path, model_path):
data = read_dicom(raw_path)
label = read_dicom(label_path, True)
# 创建训练集
data_provider = SimpleDataProvider(data, label, n_class=2, channels=1)
# 构建网络
net = unet.Unet(layers=3,
features_root=32,
channels=1,
n_class=2,
summaries=False)
trainer = unet.Trainer(net,
batch_size=2,
opt_kwargs={'learning_rate': 0.02})
path = trainer.train(data_provider,
model_path,
training_iters=64,
epochs=100)
print(path)
def launch(data_root, output_path, training_iters, epochs, restore, layers,
features_root):
print("Using data from: %s" % data_root)
if not os.path.exists(data_root):
raise IOError("Kaggle Ultrasound Dataset not found")
data_provider = DataProvider(search_path=data_root + "/*.tif",
mean=100,
std=56)
net = unet.Unet(
channels=data_provider.channels,
n_class=data_provider.n_class,
layers=layers,
features_root=features_root,
#cost="dice_coefficient",
)
path = output_path if restore else util.create_training_path(output_path)
trainer = unet.Trainer(net,
batch_size=1,
norm_grads=False,
optimizer="adam")
path = trainer.train(data_provider,
path,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=2,
restore=restore)
x_test, y_test = data_provider(1)
prediction = net.predict(path, x_test)
print("Testing error rate: {:.2f}%".format(
unet.error_rate(prediction, util.crop_to_shape(y_test,
prediction.shape))))
def main():
restore = False
# adding measurements (loggers) to plotter
logs = []
logs.append(logger(label="train loss", color="Red"))
logs.append(logger(label="validation loss", color="Blue"))
logs.append(logger(label="validation error", color="Black"))
logs.append(logger(label="dice score", color="Green"))
plot = plotter(logs, EPOCHS, os.getcwd() + "/" + "plots")
# data provider
dp = DataProviderTiled(splits=12,
batchSize=BATCH_SIZE,
validationSize=VALIDATION_SIZE)
dp.readData()
print("DONE READING DATA")
# calculate num of iterations
iters = dp.getTrainSize() // BATCH_SIZE
# unet
opt = {"class_weights": [0.99, 0.01]}
net = unet.Unet(channels = 1, n_class = 2, layers = 3,\
features_root = 16, cost="cross_entropy", cost_kwargs={})
# trainer
options = {"momentum": 0.2, "learning_rate": 0.2, "decay_rate": 0.95}
trainer = unet.Trainer(net,
optimizer="momentum",
plotter=plot,
opt_kwargs=options)
# train model
path = trainer.train(dp, OUTPUT_PATH,training_iters = iters,epochs=EPOCHS,\
dropout=DROPOUT_KEEP_PROB, display_step = DISPLAY_STEP,restore = restore)
# plot results
plot.saveLoggers()
plot.plotLoggers()
print("DONE")
def lung_segment(path, model_path):
name = ImageSeriesReader_GetGDCMSeriesFileNames(path)
raw = ReadImage(name)
raw = sitk.Cast(raw, sitk.sitkFloat32)
raw = sitk.IntensityWindowing(raw, -1024, 1024, 0, 1.0)
arr = GetArrayFromImage(raw)
prediction = np.zeros_like(arr)
arr = arr[..., np.newaxis]
net = unet.Unet(layers=3,
features_root=32,
channels=1,
n_class=2,
summaries=False)
pre = net.predict(model_path, arr, 4)
pre = np.argmax(pre, -1)
prediction[:, 20:492, 20:492] = pre
stride = 50
index = None
for z in range(0, prediction.shape[0], stride):
for y in range(154, prediction.shape[1], stride):
for x in range(105, prediction.shape[2], stride):
patch = prediction[z:z + stride, y:y + stride, x:x + stride]
ratio = patch.mean()
if ratio > 0.95:
index = [z + stride // 2, y + stride // 2, x + stride // 2]
break
if index:
break
if index:
break
index.reverse()
# print(index)
prediction = sitk.GetImageFromArray(prediction)
prediction.CopyInformation(raw)
prediction = sitk.Cast(prediction, sitk.sitkUInt8)
prediction = sitk.ConnectedThreshold(prediction, [index], 1, 1, 1)
return prediction
def main():
np.random.seed(12345)
LAYERS = 3
pkl_fname = "data/preprocess/stage1_train_set_rgb.pkl"
images, masks = get_dataset(pkl_fname)
logging.info("read train set: %s, %s", images.shape, masks.shape)
logging.info("image:[%s, %s], mask:[%s, %s]", np.max(images), np.min(images), np.max(masks), np.min(masks))
pred_size, offset = unet_size(256, LAYERS)
logging.info("pred_size: %d, offset: %d", pred_size, offset)
images = padding_array(images, offset, default_val=0.0)
masks = padding_array(masks, offset, default_val=False)
logging.info("shape after padded: %s, %s", images.shape, masks.shape)
# images = normalize(images)
# test_data(images, masks, 1679)
data_provider = image_util.SimpleDataProvider(images, masks, channels=3)
logging.info("data_provider.channels: %s, data_provider.n_class: %s", data_provider.channels, data_provider.n_class)
# test_data_provider(data_provider)
net = unet.Unet(channels=data_provider.channels,
n_class=data_provider.n_class,
cost='cross_entropy',
layers=LAYERS,
features_root=64,
cost_kwargs=dict(regularizer=0.001),
)
batch_size = 8
net.verification_batch_size = batch_size * 2
training_iters = (images.shape[0]-1) / batch_size + 1
logging.info("batch_size: %s, iters: %s", batch_size, training_iters)
trainer = unet.Trainer(net, batch_size=batch_size, optimizer="momentum",
opt_kwargs=dict(momentum=0.9, learning_rate=0.01))
path = trainer.train(data_provider, "log/20180416-1",
training_iters=training_iters, epochs=20, display_step=2)
import os
os.environ["CUDA_VISIBLE_DEVICES"] = '2'
from __future__ import division, print_function
get_ipython().run_line_magic('matplotlib', 'inline')
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
from tf_unet import image_util
from tf_unet import unet
from tf_unet import util
# In[2]:
net = unet.Unet(channels=3, n_class=2, layers=2, features_root=300)
trainer = unet.Trainer(net,
optimizer="momentum",
opt_kwargs=dict(momentum=0.2))
# In[5]:
data_provider = image_util.ImageDataProvider(
"/mnt/ccipd_data/CCF/ccfMaskTmp/training/*.png",
data_suffix='_img.png',
mask_suffix='_mask.png')
# In[4]:
path = trainer.train(data_provider,
"./unet_trained",
}
label_cmap_list = np.array(list(label_cmap.values()))
# data_provider = ImageDataSingle("./data/cj_cut.png", "./data/cj_cut_gt.png")
# data_provider = ImageDataSingle("./data/cj_test1.png", "./data/cj_test1_gt.png")
data_provider = ImageDataSingle(
"./data/cj_0402_1420/cj_right_all_20200402_1420.png",
"./data/cj_0402_1420/cj_right_all_20200402_1420_gt.png")
output_path = "./log_l3_best"
n_class = 7
class_weights = np.ones(n_class) * 5
class_weights[0] = 0.5
net = unet.Unet(data_provider.channels,
n_class,
layers=3,
features_root=32,
cost_kwargs={"class_weights": class_weights})
def predict_panoroma(path, data_provider):
pass
def stack_imgs(imgs, num_row, num_col):
'''
concatenate image slices to a panoroma,
imgs: image slices should be sorted by row first
'''
imgs_row = []
for i in range(num_row):
dp = rfc.DataProvider(ny=ws,
a_min=0,
a_max=200,
files=files_list,
label_name='gt_mask',
n_class=2)
_, nx, ny, _ = dp(1)[0].shape
training_iters = 100
epochs = 300
model_dir = './models/unet_' + str(features_root) + '_' + str(threshold)
net = unet.Unet(channels=dp.channels,
n_class=dp.n_class,
layers=3,
features_root=features_root,
cost_kwargs=dict(regularizer=0.001))
if not args.test:
trainer = unet.Trainer(net,
optimizer="momentum",
opt_kwargs=dict(momentum=0.2))
path = trainer.train(dp,
model_dir,
training_iters=training_iters,
epochs=epochs,
dropout=0.5,
display_step=1000000)
else:
from tf_unet import util
if __name__ == '__main__':
nx = 572
ny = 572
training_iters = 20
epochs = 100
dropout = 0.75 # Dropout, probability to keep units
display_step = 2
restore = False
generator = image_gen.get_image_gen_rgb(nx, ny, cnt=20)
net = unet.Unet(channels=generator.channels, n_class=generator.n_class, layers=3, features_root=16)
trainer = unet.Trainer(net, optimizer="momentum", opt_kwargs=dict(momentum=0.2))
path = trainer.train(generator, "./unet_trained",
training_iters=training_iters,
epochs=epochs,
dropout=dropout,
display_step=display_step,
restore=restore)
x_test, y_test = generator(4)
prediction = net.predict(path, x_test)
print("Testing error rate: {:.2f}%".format(unet.error_rate(prediction, util.crop_to_shape(y_test, prediction.shape))))
import numpy as np
