def request_schema(self, key, val):
"""
Converter for request schema.
Args:
. key - key name in the schema.
. val - the key value.
"""
logging.debug(f'request schema key => {key} , val => {val}')
res = ""
if key in ["style", "process_query", "apm_stats_query"]:
res += block(key, val, assignmentString)
elif key in ["metadata", "conditional_formats"]:
res += block_list(key, val, assignmentString)
elif key in [
"log_query", "rum_query", "apm_query", "security_query",
"network_query"
]:
res += block(key, val, self.request_nested_schema)
elif key in ["fill", "size"]:
res += block(key, val, self.request_schema)
elif key in ["profile_metrics_query"]: #unsupported keys
pass
else:
res += assignmentString(key, val)
return res
def searchForColorPoints(im, criteria):
points = []
pointColors = []
hsvIm = cv2.cvtColor(im, cv2.COLOR_BGR2HSV_FULL)
for i in range(11, im.shape[1] - 11, 10):
for j in range(11, im.shape[0] - 11, 10):
b = block(hsvIm, (i, j), 8)
if b[:, :, 0].std() > 25:
continue
color = (b[:, :, 0].mean(), b[:, :, 1].mean(), b[:, :, 2].mean())
matchedColor = matchColor(color, criteria)
if matchedColor >= 0:
points.append((i, j))
pointColors.append(matchedColor)
points = np.array(points, np.float16)
cluster = fclusterdata(points, 10, "distance")
centroids = []
for i in range(len(criteria)):
centroids.append([])
for i in range(1, cluster.max() + 1):
b = cluster == i
c = np.zeros((1, 2), np.int16)
for p in points[b.argsort()[len(b) - sum(b) :]]:
c = c + p / sum(b)
centroids[pointColors[b.argsort()[len(b) - sum(b)]]].append(c[0])
return centroids
def group_by_schema(self, key, val):
"""
Converter for group_by schema.
Args:
. key - key name in the schema.
. val - the key value.
"""
logging.debug(f'group_by schema key => {key} , val => {val}')
res = ""
if key in ["sort"]:
res += block("sort_query", val, assignmentString)
elif key in ["sort_query"]:
res += block("sort_query", val, assignmentString)
else:
res += assignmentString(key, val)
return res
def i3conf_bar():
return lines(
"# Bar",
block(
"bar",
# row("status_command", "i3status"),
row("output", "LVDS1"),
row("status_command", "i3status"),
row("position", "bottom"),
"font xft:{} 7".format(font),
row("separator_symbol", quotes(" · ")),
block("colors", row("background", color.bg),
row("statusline", color.fg), row("separator", color.main),
row("focused_workspace", color.main, color.bg, color.main),
row("active_workspace", color.bg, color.bg, "#5f676a"),
row("inactive_workspace", color.bg, color.bg, color.fg),
row("urgent_workspace", color.alert, color.bg, color.alert),
"")),
"")
def widget_definition_schema(self, content):
"""
Converter for widget dfinition schema.
Args:
. content - the content dict of the widget definition.
"""
logging.debug(f'widget definition schema content => \n {content}')
res = ""
for key, val in content.items():
if key in [
"type", "legend_layout", "legend_columns",
"global_time_target", "reflow_type"
]:
pass
elif key == "custom_links":
res += block_list("custom_link", val, assignmentString)
elif key == "requests":
res += block_list("request", val,
self.request_schema) if isinstance(
val, list) else block(
"request", val, self.request_schema)
elif key == "widgets":
res += block_list("widget", val, self.widget_schema)
elif key == "events":
res += block_list("event", val, assignmentString)
elif key == "markers":
res += block_list("marker", val, assignmentString)
elif key == "sort":
res += assignmentString("sort", val) if isinstance(
content, str) else block_list("sort", val,
assignmentString)
elif key in [
"event", "right_yaxis", "widget_layout", "xaxis", "yaxis",
"style"
]:
res += block(key, val, assignmentString)
elif key == "time":
res += assignmentString("live_span", val["live_span"])
else:
res += assignmentString(key, val)
definition_type = "service_level_objective" if content[
"type"] == "slo" else content["type"]
return f'\n {definition_type}_definition {{ {res} \n }}'
def __init__(self, k_shots, num_classes, win_len, model=cnn):
super(Net, self).__init__()
self.fuse = Fusion()
self.model = model
if cfg.data == 'WIFI':
self.fc = nn.Sequential(*utils.block('BN', 60 * 2, cfg.hid_dim))
self.lstm_time = nn.LSTM(60, cfg.hid_dim // 2)
self.lstm_freq = nn.LSTM(60, cfg.hid_dim // 2)
elif cfg.data == 'UWB':
self.fc = nn.Sequential(*utils.block('BN', 138 * 2, cfg.hid_dim))
self.lstm_time = nn.LSTM(138, cfg.hid_dim // 2)
self.lstm_freq = nn.LSTM(138, cfg.hid_dim // 2)
elif cfg.data == 'FMCW':
self.fc = nn.Sequential(*utils.block('BN', 253 * 2, cfg.hid_dim))
self.lstm_time = nn.LSTM(253, cfg.hid_dim // 2)
self.lstm_freq = nn.LSTM(253, cfg.hid_dim // 2)
self.classifier = nn.Linear(output_dim, cfg.num_class)
self.attention = weight_norm(BiAttention(
time_features=cfg.hid_dim // 2,
freq_features=cfg.hid_dim // 2,
mid_features=cfg.hid_dim,
glimpses=1,
drop=0.5,
),
name='h_weight',
dim=None)
self.apply_attention = ApplyAttention(
time_features=cfg.hid_dim // 2,
freq_features=cfg.hid_dim // 2,
mid_features=cfg.hid_dim // 2,
glimpses=1,
num_obj=512,
drop=0.2,
)
self.cnn1 = torch.nn.Conv2d(2, 3, kernel_size=3, stride=1, padding=1)
self.fc1 = FCNet(cfg.hid_dim // 2, cfg.hid_dim // 2, 'relu', 0.4)
self.fc2 = FCNet(cfg.hid_dim // 2, cfg.hid_dim // 2, 'relu', 0.4)
self.fc3 = FCNet(cfg.hid_dim, cfg.hid_dim, drop=0.4)
def request_nested_schema(self, key, val):
"""
Converter for request nested schema.
Args:
. key - key name in the schema.
. val - the key value.
"""
logging.debug(f'request nested schema key => {key} , val => {val}')
res = ""
if key in ["search"]:
res += assignmentString("search_query", val["query"])
elif key in ["compute"]:
res += block("compute_query", val, assignmentString)
elif key in ["compute_query"]:
res += block("compute_query", val, assignmentString)
elif key in ["multi_compute"]:
pass
elif key in ["group_by"]:
res += block_list("group_by", val, self.group_by_schema)
else:
res += assignmentString(key, val)
return res
def i3conf_bar():
return lines("# Bar",
block("bar",
# row("status_command", "i3status"),
row("output", "LVDS1"),
row("status_command", "i3status"),
row("position", "bottom"),
"font xft:{} 7".format(font),
row("separator_symbol", quotes(" · ")),
block("colors",
row("background", color.bg),
row("statusline", color.fg),
row("separator", color.main),
row("focused_workspace",
color.main, color.bg, color.main),
row("active_workspace",
color.bg, color.bg, "#5f676a"),
row("inactive_workspace",
color.bg, color.bg, color.fg),
row("urgent_workspace",
color.alert, color.bg, color.alert),
"")
),
"")
def widget_schema(self, key, val):
"""
Converter for widget schema.
Args:
. key - key name in the schema.
. val - the key value.
"""
logging.debug(f'widget schema key => {key} , val => {val}')
res = ""
if key in ["id"]:
pass
elif key == "definition":
res += self.widget_definition_schema(val)
elif key == "layout":
res += block("widget_layout", val, assignmentString)
return res
def options_schema(self, content):
"""
Converter of options block.
Args:
. content - options dict.
"""
logging.debug(f'Monitor options schema content => \n {content}')
res = ""
for key, val in content.items():
if key in ["thresholds"]:
# res += self.block("monitor_thresholds", val, assignmentString)
res += block("monitor_thresholds", val, assignmentString)
elif key in ["silenced"]:
# res += self.block(key, val, assignmentString)
# res += block(key, val, assignmentString)
pass # unsupported block tyep.
else:
res += assignmentString(key, val)
return res
def recall_command(request):
data = request.form
team_id, user_id, text = data['team_id'], data['user_id'], data['text']
items = recall(team_id, user_id, text)
items_text = "\n".join(["%s. %s" % (i, x) for i, x in enumerate(items, 1)])
block_args = [
('mrkdwn', "Recalling `{}`".format(text)),
('divider',),
('mrkdwn', items_text),
('divider',),
('mrkdwn', "_Trying filtering by tag and date_ `/recall last 7 days #mgmt`."),
('mrkdwn', "_Share your response with the room by adding `public` anywhere in your response_"),
]
resp = {
"text": items_text,
"response_type": "in_channel" if "public" in text else "ephemeral",
"blocks": [block(*args) for args in block_args]
}
return jsonify(resp)
def app_home_opened_event(request):
parsed = request.json
user_id = parsed['event']['user']
team_id = parsed['team_id']
items = recall(team_id, user_id, "last 14 days")
items_text = "\n".join(["%s. %s" % (i, x) for i, x in enumerate(items, 1)])
blocks_spec = [
('mrkdwn', "Your home tab for Reflect"),
('divider', ),
('mrkdwn', items_text),
('divider', ),
('mrkdwn', "Some more stuff here"),
]
blocks = [block(*x) for x in blocks_spec]
msg = {
"user_id": user_id,
"view": {
"type": "home",
"blocks": blocks,
}
}
resp = slack_api(team_id, "views.publish", msg)
return "OK"
def __init__(self,
args,
d_model,
frefine_layers,
brefine_layers,
drefine_layers,
dcrefine_layers,
dense_fusion=False,
conv_fusion=False,
flatten=False):
super().__init__()
self.args = args
self.d_model = d_model
self.dim = d_model
self.fusion_strategy = self.args.view_fusion_strategy
self.dense_fusion = dense_fusion
self.conv_fusion = conv_fusion
# self.params = []
self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
self.drefine_nlayers = drefine_layers
self.brefine_nlayers = brefine_layers
self.frefine_nlayers = frefine_layers
self.dcrefine_nlayers = dcrefine_layers
# print(self.dense_fusion, self.conv_fusion)
if self.drefine_nlayers > 0:
drefine_layers = []
for i in range(self.drefine_nlayers):
drefine_layers.append(dblock(self.dim, self.dim))
drefine_layers.append(nn.Dropout(0.5))
self.dense_project_layers = nn.Sequential(*drefine_layers)
# self.params += list(self.dense_project_layers.parameters())
if self.dense_fusion:
if self.frefine_nlayers > 0:
frefine_layers = []
for i in range(self.frefine_nlayers):
frefine_layers.append(dblock(6 * self.dim, 6 * self.dim))
frefine_layers.append(nn.Dropout(0.5))
self.refine_before_fuse = nn.Sequential(*frefine_layers)
if "concat" in self.fusion_strategy:
reduce_layers = []
reduce_layers.append(dblock(int(6 * self.dim), int(self.dim)))
reduce_layers.append(nn.Dropout(0.5))
self.reduce_views = nn.Sequential(*reduce_layers)
if self.brefine_nlayers > 0:
brefine_layers = []
for i in range(self.brefine_nlayers):
brefine_layers.append(dblock(self.dim, self.dim))
brefine_layers.append(nn.Dropout(0.5))
self.refine_after_fuse = nn.Sequential(*brefine_layers)
if self.conv_fusion:
if self.drefine_nlayers > 0:
self.reshape = dblock(self.dim, 16 * 16 * 32)
self.conv_refine = nn.Sequential(block(32, 64, 3, 1, 1),
Resblock(64, 64, 3, 1, 1))
self.dim = 64
if self.frefine_nlayers > 0:
frefine_layers = []
for i in range(self.frefine_nlayers):
frefine_layers.append(
Resblock(int(6 * self.dim), int(6 * self.dim), 3, 1,
1))
self.refine_before_fuse = nn.Sequential(*frefine_layers)
if "concat" in self.fusion_strategy:
self.reduce_views = block(int(6 * self.dim), int(self.dim), 3,
1, 1)
if self.brefine_nlayers > 0:
brefine_layers = []
for i in range(self.brefine_nlayers):
brefine_layers.append(
Resblock(int(self.dim), int(self.dim), 3, 1, 1))
self.refine_after_fuse = nn.Sequential(*brefine_layers)
if self.dcrefine_nlayers > 0:
dcrefine_layers = []
for i in range(self.dcrefine_nlayers):
if i == 0 and "cond" in self.args.finetune_obj:
dcrefine_layers.append(
dblock(self.dim + self.args.latent_dim, self.dim))
else:
dcrefine_layers.append(dblock(self.dim, self.dim))
dcrefine_layers.append(nn.Dropout(0.5))
dcrefine_layers.append(dblock(self.dim, 16 * 16 * 32))
self.refine = Resblock(32, 32, 3, 1, 1)
self.dense_reduce_layers = nn.Sequential(*dcrefine_layers)
else:
if self.dense_fusion:
self.reshape = dblock(self.dim, 16 * 16 * 32)
self.refine = Resblock(32, 32, 3, 1, 1)
# self.reduce = []
# if self.frefine_nlayers > 0:
# self.params += list(self.refine_before_fuse.parameters())
# # self.reduce.append(self.refine_before_fuse)
# # self.reduce.append(self.reduce_views)
# if "concat" in self.fusion_strategy:
# self.params += list(self.reduce_views.parameters())
# if self.brefine_nlayers > 0:
# self.params += list(self.refine_after_fuse.parameters())
# self.reduce.append(self.refine_after_fuse)
self.dropout = torch.nn.Dropout(p=0.5, inplace=False)
def __init__(self,
args,
init_layer_dim,
init_channel_dim,
max_f,
d_model,
add_convs_before_decoding=False,
add_initial_upsample_conv=False):
super().__init__()
decoder_network_layers = []
self.args = args
self.max_f = max_f
self.init_layer_dim = init_layer_dim
self.init_channel_dim = init_channel_dim
self.d_model = d_model
self.input_dim = 256
if add_initial_upsample_conv:
decoder_network_layers.append(
block(int(init_channel_dim // 2),
int(init_channel_dim),
3,
1,
1,
upsample=True))
decoder_network_layers.append(
block(int(init_channel_dim),
int(init_channel_dim),
3,
1,
1,
activation="identity"))
if add_convs_before_decoding:
# print("add_convs_before_decoding",add_convs_before_decoding)
decoder_network_layers.append(
block((self.d_model), int(self.init_channel_dim), 3, 1, 1))
#
decoder_network_layers.append(
block(int(self.d_model // 4),
int(self.init_channel_dim),
3,
1,
1,
activation='identity'))
while self.init_layer_dim < self.input_dim:
decoder_network_layers.append(
block(int(self.init_channel_dim),
int(self.init_channel_dim // 2),
3,
1,
1,
upsample=True))
decoder_network_layers.append(
block(int(self.init_channel_dim // 2),
int(self.init_channel_dim // 2),
3,
1,
1,
activation="identity"))
self.init_layer_dim *= 2
self.init_channel_dim = self.init_channel_dim / 2
# decoder_network_layers.append(
# nn.ZeroPad2d((1,0,1,0))
# )
if self.args.gen_road_map:
outdim = 1
elif self.args.gen_semantic_map:
outdim = 11
else:
outdim = 3
decoder_network_layers.append(
block(int(self.init_channel_dim),
outdim,
3,
1,
1,
activation="identity",
norm=False), )
self.decoder_network = nn.Sequential(*decoder_network_layers)
def ShuffleNetV2(include_top=True,
input_tensor=None,
scale_factor=1.0,
pooling='max',
input_shape=(224,224,3),
load_model=None,
num_shuffle_units=[3,7,3],
bottleneck_ratio=1,
classes=1000):
if K.backend() != 'tensorflow':
raise RuntimeError('Only tensorflow supported for now')
name = 'ShuffleNetV2_{}_{}_{}'.format(scale_factor, bottleneck_ratio, "".join([str(x) for x in num_shuffle_units]))
input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=28, require_flatten=include_top,
data_format=K.image_data_format())
out_dim_stage_two = {0.5:48, 1:116, 1.5:176, 2:244}
if pooling not in ['max', 'avg']:
raise ValueError('Invalid value for pooling')
if not (float(scale_factor)*4).is_integer():
raise ValueError('Invalid value for scale_factor, should be x over 4')
exp = np.insert(np.arange(len(num_shuffle_units), dtype=np.float32), 0, 0) # [0., 0., 1., 2.]
out_channels_in_stage = 2**exp
out_channels_in_stage *= out_dim_stage_two[bottleneck_ratio] # calculate output channels for each stage
out_channels_in_stage[0] = 24 # first stage has always 24 output channels
out_channels_in_stage *= scale_factor
out_channels_in_stage = out_channels_in_stage.astype(int)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# create shufflenet architecture
x = Conv2D(filters=out_channels_in_stage[0], kernel_size=(3, 3), padding='same', use_bias=False, strides=(2, 2),
activation='relu', name='conv1')(img_input)
x = MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding='same', name='maxpool1')(x)
# create stages containing shufflenet units beginning at stage 2
for stage in range(len(num_shuffle_units)):
repeat = num_shuffle_units[stage]
x = block(x, out_channels_in_stage,
repeat=repeat,
bottleneck_ratio=bottleneck_ratio,
stage=stage + 2)
if bottleneck_ratio < 2:
k = 1024
else:
k = 2048
x = Conv2D(k, kernel_size=1, padding='same', strides=1, name='1x1conv5_out', activation='relu')(x)
if pooling == 'avg':
x = GlobalAveragePooling2D(name='global_avg_pool')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='global_max_pool')(x)
if include_top:
x = Dense(classes, name='fc')(x)
x = Activation('softmax', name='softmax')(x)
if input_tensor:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
model = Model(inputs, x, name=name)
if load_model:
model.load_weights('', by_name=True)
return model
def __init__(self, args):
super().__init__(args)
self.args = args
self.num_patches = args.num_patches
self.d_model = OUT_BLOCK4_DIMENSION_DICT[self.args.network_base]
full_resnet = get_base_model(self.args.network_base)
self.init_layers = nn.Sequential(
full_resnet.conv1,
full_resnet.bn1,
full_resnet.relu,
full_resnet.maxpool,
)
self.block1 = full_resnet.layer1
self.block2 = full_resnet.layer2
self.block3 = full_resnet.layer3
self.block4 = full_resnet.layer4
self.image_network = nn.Sequential(
self.init_layers,
self.block1,
self.block2,
self.block3,
self.block4,
)
if self.d_model > 1024:
self.max_f = 1024
else:
self.max_f = self.d_model
if self.args.view_pretrain_obj != "none":
self.model_type = self.args.view_pretrain_obj.split("_")[0]
else:
self.model_type = "var"
self.input_dim = 256
self.latent_dim = self.args.latent_dim
self.mask_ninps = 1
self.reduce = nn.Conv2d(6 * self.d_model,
self.d_model,
kernel_size=1,
stride=1)
if self.model_type == "det":
decoder_network_layers = []
decoder_network_layers.append(
block(int(self.d_model), int(self.max_f), 2, 2, 0))
init_layer_dim = int(self.input_dim // 16)
init_channel_dim = self.max_f
while init_layer_dim < self.input_dim:
decoder_network_layers.append(
block(int(init_channel_dim), int(init_channel_dim // 2), 2,
2, 0), )
init_layer_dim *= 2
init_channel_dim = init_channel_dim / 2
if self.stage != "pretrain":
out_dim = 1
else:
out_dim = 3
decoder_network_layers.append(
block(int(init_channel_dim), out_dim, 3, 1, 1, "sigmoid",
False, False), )
self.decoder_network = nn.Sequential(*decoder_network_layers)
self.decoding = nn.Sequential(self.decoder_network)
self.loss_type = "bce"
else:
decoder_network_layers = []
decoder_network_layers.append(
block(int(self.latent_dim), int(self.max_f), 4, 1, 0,
"leakyrelu"), )
init_layer_dim = 4
init_channel_dim = self.max_f
while init_layer_dim < self.input_dim:
decoder_network_layers.append(
block(int(init_channel_dim), int(init_channel_dim // 2), 4,
2, 1, "leakyrelu"), )
init_layer_dim *= 2
init_channel_dim = init_channel_dim / 2
if self.stage == "pretrain":
decoder_network_layers.append(
block(int(init_channel_dim), 3, 3, 1, 1, "tanh", False,
False), )
else:
decoder_network_layers.append(
block(int(init_channel_dim), 1, 3, 1, 1, "sigmoid", False,
False), )
self.decoder_network = nn.Sequential(*decoder_network_layers)
self.z_project = nn.Linear(self.d_model, 2 * self.latent_dim)
# self.reduce = nn.Linear((6-self.mask_ninps) * self.d_model, self.d_model)
self.decoding = nn.Sequential(self.decoder_network, self.z_project)
self.loss_type = "mse"
if self.loss_type == "mse":
self.criterion = torch.nn.MSELoss()
elif self.loss_type == "bce":
self.criterion = torch.nn.BCELoss()
self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
self.n_synthesize = self.args.synthesizer_nlayers
if self.n_synthesize > 0:
synthesizer_layers = []
for i in range(self.n_synthesize):
synthesizer_layers.append(
Resblock(self.d_model, self.d_model, 3, 1, 1))
self.synthesizer = nn.Sequential(*synthesizer_layers)
self.fusion = self.args.view_fusion_strategy
self.dropout = torch.nn.Dropout(p=0.5, inplace=False)
self.det_fusion_strategy = "concat_fuse"
assert self.det_fusion_strategy in ["concat_fuse", "mean"]
self.sigmoid = nn.Sigmoid()
self.shared_params = list(self.image_network.parameters())
self.pretrain_params = list(self.reduce.parameters()) + list(
self.decoding.parameters()) + list(self.synthesizer.parameters())
def shufflenet(images, is_training, num_classes=1000, depth_multiplier='1.0'):
"""
This is an implementation of ShuffleNet v2:
https://arxiv.org/abs/1807.11164
Arguments:
images: a float tensor with shape [batch_size, image_height, image_width, 3],
a batch of RGB images with pixel values in the range [0, 1].
is_training: a boolean.
num_classes: an integer.
depth_multiplier: a string, possible values are '0.5', '1.0', '1.5', and '2.0'.
Returns:
a float tensor with shape [batch_size, num_classes].
"""
possibilities = {'0.5': 48, '1.0': 116, '1.5': 176, '2.0': 224}
# 116 is not divisible by 8,
# so maybe you need to change it when training on TPUs
initial_depth = possibilities[depth_multiplier]
def batch_norm(x):
x = tf.layers.batch_normalization(x,
axis=3,
center=True,
scale=True,
training=is_training,
momentum=BATCH_NORM_MOMENTUM,
epsilon=BATCH_NORM_EPSILON,
fused=True,
name='batch_norm')
return x
with tf.name_scope('standardize_input'):
x = (2.0 * images) - 1.0
with tf.variable_scope('ShuffleNetV2'):
params = {
'padding': 'SAME',
'activation_fn': tf.nn.relu,
'normalizer_fn': batch_norm,
'data_format': 'NHWC',
'weights_initializer': tf.variance_scaling_initializer()
}
with slim.arg_scope([slim.conv2d, slim.separable_conv2d], **params):
x = slim.conv2d(x, 24, (3, 3), stride=2, scope='Conv1')
x = slim.max_pool2d(x, (3, 3),
stride=2,
padding='SAME',
scope='MaxPool')
x = block(x,
num_units=4,
out_channels=initial_depth,
scope='Stage2')
x = block(x, num_units=8, scope='Stage3')
x = block(x, num_units=4, scope='Stage4')
final_channels = 1024 if depth_multiplier != '2.0' else 2048
x = slim.conv2d(x, final_channels, (1, 1), stride=1, scope='Conv5')
# global average pooling
x = tf.reduce_mean(x, axis=[1, 2])
logits = slim.fully_connected(
x,
num_classes,
activation_fn=None,
scope='classifier',
weights_initializer=tf.truncated_normal_initializer(stddev=0.01))
return logits
def large_shufflenet(images, is_training, num_classes=1000):
"""
This is an implementation of ShuffleNet v2-50:
https://arxiv.org/abs/1807.11164
It is a more fast/accurate alternative to ResNet-50.
Arguments:
images: a float tensor with shape [batch_size, image_height, image_width, 3],
a batch of RGB images with pixel values in the range [0, 1].
is_training: a boolean.
num_classes: an integer.
Returns:
a float tensor with shape [batch_size, num_classes].
"""
initial_depth = 240
# in the original paper 244, but i want it to be divisible by 8.
# it is recommended for TPUs
def batch_norm(x):
x = tf.layers.batch_normalization(x,
axis=3,
center=True,
scale=True,
training=is_training,
momentum=BATCH_NORM_MOMENTUM,
epsilon=BATCH_NORM_EPSILON,
fused=True,
name='batch_norm')
return x
with tf.name_scope('standardize_input'):
x = (2.0 * images) - 1.0
with tf.variable_scope('ShuffleNetV2-50'):
params = {
'padding': 'SAME',
'activation_fn': tf.nn.relu,
'normalizer_fn': batch_norm,
'data_format': 'NHWC',
'weights_initializer': tf.variance_scaling_initializer()
}
with slim.arg_scope([slim.conv2d, slim.separable_conv2d], **params):
x = slim.conv2d(x, 64, (3, 3), stride=2, scope='Conv1')
x = slim.max_pool2d(x, (3, 3),
stride=2,
padding='SAME',
scope='MaxPool')
x = block(x,
num_units=3,
out_channels=initial_depth,
downsample=False,
scope='Stage2')
x = block(x, num_units=4, scope='Stage3')
x = block(x, num_units=6, scope='Stage4')
x = block(x, num_units=3, scope='Stage5')
x = slim.conv2d(x, 2048, (1, 1), stride=1, scope='Conv6')
# number of conv layers in the network:
# 1 + (3 + 4 + 6 + 3)*3 + 1 = 50
# global average pooling
x = tf.reduce_mean(x, axis=[1, 2])
logits = slim.fully_connected(
x,
num_classes,
activation_fn=None,
scope='classifier',
weights_initializer=tf.truncated_normal_initializer(stddev=0.01))
return logits
def __init__(self, args):
super().__init__()
self.args = args
self.stage = None
self.disc_finetune_params = []
self.type = self.args.disc_type
if "patch" in self.type:
channels = [16, 32, 64, 128, 1]
else:
channels = [64, 128, 256, 256, 512, 512, 512]
network_layers = []
if self.args.gen_road_map:
initc = 1
elif self.args.gen_semantic_map:
initc = 11
else:
initc = 3
for i, channel in enumerate(channels):
if i == len(channels) - 1 and "patch" in self.type:
network_layers.append(
block(initc,
channel,
3,
1,
1,
activation="sigmoid",
norm=False))
elif i == 0:
network_layers.append(
block(initc,
channel,
4,
2,
1,
activation="leakyrelu",
norm=False))
else:
network_layers.append(
block(initc, channel, 4, 2, 1, activation="leakyrelu"))
initc = channel
self.network = nn.Sequential(*network_layers)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
self.disc_finetune_params += list(self.network.parameters())
if "patch" not in self.type:
self.final = dblock(2048, 1, activation="sigmoid")
self.disc_finetune_params += list(self.final.parameters())
optimizer = pargs.optimizer(model.parameters())
optimizer = pargs.optimizer([{'params': model.flow.parameters()},
{'params': model.parameters(recurse=False), 'lr': 0.01}] +
([{'params': model.A.parameters(), 'lr': 0.01}] if hasattr(model, 'A') else []))
trainer = pargs.trainer(_logname=pargs.name)
scheduler = pargs.scheduler(optimizer)
if pargs.cuda:
#model = torch.nn.DataParallel(model)
#model_obj = model.module
model.cuda()
trainer.cuda()
if len(pargs.resume) > 0:
with utils.block('Resume', exit_on_error=True) as b:
path = trainer.resume(model, optimizer, pargs.resume, uid=pargs.resume_uid, unique=False)
b.print('Successfully Resumed: {}'.format(path))
b.print(trainer.state_dict)
with utils.block('Command') as b:
b.print(pargs.command())
b.print('Stub: ' + pargs.stub())
trainer.log(0, **{':command': pargs.command()})
with utils.block('Arguments') as b:
b.print(pargs, indent=False)
trainer.log(0, **{':arguments': repr(pargs)})
with utils.block('Parameters') as b:
b.print(utils.pytorch_summary(model, verbose=pargs.print_model), indent=False)
