def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
cags = CAGS()
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False)
# TODO: Create the model and train it
model = ...
# Generate test set annotations, but in args.logdir to allow parallel execution.
with open(os.path.join(args.logdir, "cags_classification.txt"),
"w",
encoding="utf-8") as predictions_file:
# TODO: Predict the probabilities on the test set
test_probabilities = model.predict(...)
for probs in test_probabilities:
print(np.argmax(probs), file=predictions_file)
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Load EfficientNet=B0
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(include_top=True)
for image_path in args.images:
# Load the file
with open(image_path, "rb") as image_file:
image = tf.image.decode_image(image_file.read(), channels=3, dtype=tf.float32)
# Resize to 224,224
image = tf.image.resize(image, size=(224, 224))
# Compute the prediction
start = time.time()
[prediction], *_ = efficientnet_b0.predict(tf.expand_dims(image, 0))
print("Image {} [{} ms]: label {}".format(
image_path,
1000 * (time.time() - start),
imagenet_classes.imagenet_classes[tf.argmax(prediction)]
))
def main(args: argparse.Namespace) -> None:
# Fix random seeds and threads
tf.keras.utils.set_random_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", k), v)
for k, v in sorted(vars(args).items())))))
# Load the data
cags = CAGS()
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False)
# TODO: Create the model and train it
model = ...
# Generate test set annotations, but in `args.logdir` to allow parallel execution.
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "cags_segmentation.txt"),
"w",
encoding="utf-8") as predictions_file:
# TODO: Predict the masks on the test set
test_masks = model.predict(...)
for mask in test_masks:
zeros, ones, runs = 0, 0, []
for pixel in np.reshape(mask >= 0.5, [-1]):
if pixel:
if zeros or (not zeros and not ones):
runs.append(zeros)
zeros = 0
ones += 1
else:
if ones:
runs.append(ones)
ones = 0
zeros += 1
runs.append(zeros + ones)
print(*runs, file=predictions_file)
def efficient_net(self, args):
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False, drop_connect=args.drop_connect)
for lidx, layer in enumerate(efficientnet_b0.layers):
if ('conv' in layer.name or 'expand' in layer.name
or 'reduce' in layer.name):
layer.kernel_regularizer = tf.keras.regularizers.l2(args.l2)
if ('drop' in layer.name or 'bg' in layer.name
or 'gn' in layer.name):
layer.trainable = True
else:
layer.trainable = False
return efficientnet_b0
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
svhn = SVHN()
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False)
# TODO: Create the model and train it
model = ...
# Generate test set annotations, but in args.logdir to allow parallel execution.
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "svhn_competition.txt"),
"w",
encoding="utf-8") as predictions_file:
# TODO: Predict the digits and their bounding boxes on the test set.
# Assume that for a single test image we get
# - `predicted_classes`: a 1D array with the predicted digits,
# - `predicted_bboxes`: a [len(predicted_classes), 4] array with bboxes;
for predicted_classes, predicted_bboxes in ...:
output = []
for label, bbox in zip(predicted_classes, predicted_bboxes):
output += [label] + list(bbox)
print(*output, file=predictions_file)
def __init__(self, args):
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False)
hidden = efficientnet_b0.outputs
# MASK LAYER
# Pyramid block 1
#bn1 = layers.BatchNormalization()(hidden[1])
#conv1 = layers.Conv2D(filters=64, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn1)
#bn2 = layers.BatchNormalization()(conv1)
#conv2 = layers.Conv2D(filters=64, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn2)
#shortcut1 = layers.Conv2D(filters=64, kernel_size=(1,1), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn1)
#out1 = layers.add([conv2, shortcut1])
# Pyramid block 2
#bn3 = layers.BatchNormalization()(out1)
#conv3 = layers.Conv2D(filters=32, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn3)
#bn4 = layers.BatchNormalization()(conv3)
#conv4 = layers.Conv2D(filters=32, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn4)
#shortcut2 = layers.Conv2D(filters=32, kernel_size=(1,1), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn3)
#out2 = layers.add([conv4, shortcut2])
#bn5 = layers.BatchNormalization()(out2)
#conv5 = layers.Conv2D(filters=64, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn5)
#bn6 = layers.BatchNormalization()(conv5)
#conv6 = layers.Conv2D(filters=64, kernel_size=(3,3), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn6)
#shortcut3 = layers.Conv2D(filters=64, kernel_size=(1,1), strides = 1, padding='same', use_bias=False, activation = tf.nn.relu)(bn5)
#out3 = layers.add([conv6, shortcut3])
#tmp = tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=2)(out3)
#tmp = layers.BatchNormalization()(tmp)
EFNet_out = efficientnet_b0.outputs[1:][::-1]
down_stack = tf.keras.Model(inputs=efficientnet_b0.inputs,
outputs=EFNet_out)
print(EFNet_out)
inputs = layers.Input(shape=[224, 224, 3])
x = inputs
skips = down_stack(x)
print(skips)
x = skips[-1]
skips = reversed(skips[:-1])
print(skips)
up_stack = [
upsample(512, 3),
upsample(256, 3),
upsample(128, 3),
upsample(64, 3)
]
for up, skip in zip(up_stack, skips):
x = up(x)
layers.Concatenate()([x, skip])
# x = layers.BatchNormalization()(x)
masks_layer = layers.Conv2DTranspose(filters=1,
kernel_size=3,
strides=2,
padding="same",
use_bias=True,
activation=tf.nn.sigmoid)(x)
super().__init__(inputs=inputs, outputs=[masks_layer])
opt = tf.keras.optimizers.RMSprop(args.opt[1]) if args.opt[0] == 'rms' \
else tf.keras.optimizers.Adam()
self.compile(
optimizer=opt,
loss=[
#tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
tf.keras.losses.BinaryCrossentropy()
],
metrics=[CAGSMaskIoU()])
# Report only errors by default
if not args.verbose:
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
# Create logdir name
args.logdir = os.path.join("logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"),
",".join(("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value) for key, value in sorted(vars(args).items())))
))
# Load the data
cags = CAGS()
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(include_top=False)
def train_augment(e):
image = e["image"]
label = e["label"]
if tf.random.uniform([]) >= 0.5:
image = tf.image.flip_left_right(image)
image = tf.image.resize_with_crop_or_pad(image, CAGS.H + 12, CAGS.W + 12)
image = tf.image.resize(image, [tf.random.uniform([], minval=CAGS.H, maxval=CAGS.H + 24, dtype=tf.int32),
tf.random.uniform([], minval=CAGS.W, maxval=CAGS.W + 24, dtype=tf.int32)])
image = tf.image.random_crop(image, [CAGS.H, CAGS.W, CAGS.C])
return image, label
train = cags.train.map(CAGS.parse)
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join("logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"),
",".join(("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value) for key, value in sorted(vars(args).items())))
))
# Load the data
cags = CAGS()
# Load the EfficientNet-B0 model
# Return with image features, not with classification layer
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(include_top=False)
def without_mask(x):
return x["image"], x["label"]
train = cags.train
train = train.map(without_mask)
a = []
[a.append(row[1]) for row in train]
# output classification size
output_size = max(a).numpy() + 1
# length of training data - 2142 rows
set_size = len(a)
train = train.shuffle(set_size, seed=args.seed)
train = train.batch(args.batch_size)
dev = cags.dev
dev = dev.map(without_mask)
dev = dev.batch(args.batch_size)
test = cags.test
test = test.map(without_mask)
test = test.batch(args.batch_size)
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
# Adding last additional dense layer
inter_input = tf.keras.layers.Dense(5000, activation='relu')(efficientnet_b0.outputs[0])
output = tf.keras.layers.Dense(output_size, activation='softmax')(inter_input)
# TODO: Create the model and train it
model = tf.keras.Model(inputs=efficientnet_b0.inputs, outputs=output)
# model.summary()
# Define a learning rate decay
initial_lr = 0.0001
final_lr = 0.00000001
lr = tf.keras.optimizers.schedules.PolynomialDecay(initial_lr, args.epochs * set_size / args.batch_size, final_lr)
model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=lr),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=tf.keras.metrics.SparseCategoricalAccuracy(),
)
model.fit(
train,
shuffle=True,
epochs=args.epochs,
validation_data=dev, verbose=2
)
# Generate test set annotations, but in args.logdir to allow parallel execution.
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "cags_classification.txt"), "w", encoding="utf-8") as predictions_file:
# TODO: Predict the probabilities on the test set
test_probabilities = model.predict(test)
for probs in test_probabilities:
print(np.argmax(probs), file=predictions_file)
if not args.verbose:
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
svhn = SVHN()
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False, dynamic_shape=False)
# TODO: Create the model and train it
model = ...
# Generate test set annotations, but in args.logdir to allow parallel execution.
with open(os.path.join(args.logdir, "svhn_classification.txt"),
"w",
encoding="utf-8") as out_file:
# TODO: Predict the digits and their bounding boxes on the test set.
for prediction in model.predict(...):
# Assume that for the given prediction we get its
# - `predicted_classes`: a 1D array with the predicted digits,
# - `predicted_bboxes`: a [len(predicted_classes), 4] array with bboxes;
# We can then generate the required output by
output = []
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
cags = CAGS()
def with_mask(x):
return x["image"], x["mask"]
train = cags.train
train = train.map(with_mask)
train = train.shuffle(5000, seed=args.seed)
train = train.batch(args.batch_size)
dev = cags.dev
dev = dev.map(with_mask)
dev = dev.batch(args.batch_size)
test = cags.test
test = test.map(with_mask)
test = test.batch(args.batch_size)
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
# Load the EfficientNet-B0 model
efficientnet_b0 = efficient_net.pretrained_efficientnet_b0(
include_top=False)
efficientnet_b0.trainable = False
inputs = tf.keras.layers.Input([cags.H, cags.W, cags.C])
# Lets use all outputs, except first one by networks. We'll use those which are intermediate results of the network
# Not the final efficientnet output
features = efficientnet_b0(inputs)
# Lets use features for reconstruction of segmentation.
f = features[1]
f = tf.keras.layers.Conv2D(filters=128,
kernel_size=1,
padding='same',
use_bias=False)(f)
f = tf.keras.layers.BatchNormalization()(f)
f = tf.keras.layers.ReLU()(f)
for feature in features[2:]:
f = tf.keras.layers.Conv2DTranspose(filters=128,
kernel_size=3,
strides=2,
padding='same',
use_bias=False)(f)
f = tf.keras.layers.BatchNormalization()(f)
f = tf.keras.layers.ReLU()(f)
f = tf.keras.layers.Dropout(rate=0.3)(f)
f = tf.keras.layers.Conv2D(filters=128,
kernel_size=3,
padding='same',
use_bias=False)(f)
f = tf.keras.layers.BatchNormalization()(f)
f = tf.keras.layers.ReLU()(f)
f = tf.keras.layers.Dropout(rate=0.2)(f)
f = tf.keras.layers.Conv2D(filters=128,
kernel_size=3,
padding='same',
use_bias=False)(f)
f = tf.keras.layers.BatchNormalization()(f)
f = tf.keras.layers.ReLU()(f)
f = tf.keras.layers.Dropout(rate=0.1)(f)
f_1 = tf.keras.layers.Conv2D(filters=128,
kernel_size=1,
padding='same',
use_bias=False)(feature)
f_1 = tf.keras.layers.BatchNormalization()(f_1)
f_1 = tf.keras.layers.ReLU()(f_1)
f = tf.keras.layers.Dropout(rate=0.3)(f)
f = tf.keras.layers.Add()([f, f_1])
# Add last layer with transposed conv + sigmoid activation for having pixels in range [0,1]
outputs = tf.keras.layers.Conv2DTranspose(filters=1,
kernel_size=3,
strides=2,
padding='same',
activation="sigmoid")(f)
# TODO: Create the model and train it
model = tf.keras.Model(inputs=inputs, outputs=outputs)
# model.summary()
# Custom PiecewiseConstantDecay - half the learning rate at each half
def lr_schedule(epoch):
if epoch > args.epochs * 3 / 4:
lr = 0.00001
elif epoch > args.epochs / 2:
lr = 0.0001
else:
lr = 0.001
return lr
lr_scheduler = tf.keras.callbacks.LearningRateScheduler(lr_schedule)
# Compile the model
model.compile(
optimizer=tf.keras.optimizers.RMSprop(learning_rate=lr_schedule(0)),
loss=tf.losses.Huber(),
metrics=[cags.MaskIoUMetric()])
# Fit the model
model.fit(train,
shuffle=True,
epochs=args.epochs,
callbacks=[lr_scheduler],
validation_data=dev,
verbose=2)
# Generate test set annotations, but in args.logdir to allow parallel execution.
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "cags_segmentation.txt"),
"w",
encoding="utf-8") as predictions_file:
# TODO: Predict the masks on the test set
test_masks = model.predict(test)
for mask in test_masks:
zeros, ones, runs = 0, 0, []
for pixel in np.reshape(mask >= 0.5, [-1]):
if pixel:
if zeros or (not zeros and not ones):
runs.append(zeros)
zeros = 0
ones += 1
else:
if ones:
runs.append(ones)
ones = 0
zeros += 1
runs.append(zeros + ones)
print(*runs, file=predictions_file)
