wassname/ray
1
0
Fork 0
mirror of https://github.com/wassname/ray.git synced 2026-08-11 11:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Enforce quoting style in Travis. (#4589)

Browse Source
This commit is contained in:
justinwyang
2019-04-11 14:24:26 -07:00
committed by Robert Nishihara
parent 6697407ec4
commit e88e706fcc
79 changed files with 777 additions and 778 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/cython/cython_main.py
+1 -1
View File
@@ -26,7 +26,7 @@ def run_func(func, *args, **kwargs):
return result
@click.group(context_settings={'help_option_names': ['-h', '--help']})
@click.group(context_settings={"help_option_names": ["-h", "--help"]})
def cli():
"""Working with Cython actors and functions in Ray"""
examples/parameter_server/model.py
+13 -13
View File
@@ -38,16 +38,16 @@ class SimpleCNN(object):
# Build the graph for the deep net
self.y_conv, self.keep_prob = deepnn(self.x)
with tf.name_scope('loss'):
with tf.name_scope("loss"):
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
labels=self.y_, logits=self.y_conv)
self.cross_entropy = tf.reduce_mean(cross_entropy)
with tf.name_scope('adam_optimizer'):
with tf.name_scope("adam_optimizer"):
self.optimizer = tf.train.AdamOptimizer(learning_rate)
self.train_step = self.optimizer.minimize(self.cross_entropy)
with tf.name_scope('accuracy'):
with tf.name_scope("accuracy"):
correct_prediction = tf.equal(
tf.argmax(self.y_conv, 1), tf.argmax(self.y_, 1))
correct_prediction = tf.cast(correct_prediction, tf.float32)
@@ -133,32 +133,32 @@ def deepnn(x):
# Reshape to use within a convolutional neural net.
# Last dimension is for "features" - there is only one here, since images
# are grayscale -- it would be 3 for an RGB image, 4 for RGBA, etc.
with tf.name_scope('reshape'):
with tf.name_scope("reshape"):
x_image = tf.reshape(x, [-1, 28, 28, 1])
# First convolutional layer - maps one grayscale image to 32 feature maps.
with tf.name_scope('conv1'):
with tf.name_scope("conv1"):
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
# Pooling layer - downsamples by 2X.
with tf.name_scope('pool1'):
with tf.name_scope("pool1"):
h_pool1 = max_pool_2x2(h_conv1)
# Second convolutional layer -- maps 32 feature maps to 64.
with tf.name_scope('conv2'):
with tf.name_scope("conv2"):
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
# Second pooling layer.
with tf.name_scope('pool2'):
with tf.name_scope("pool2"):
h_pool2 = max_pool_2x2(h_conv2)
# Fully connected layer 1 -- after 2 round of downsampling, our 28x28 image
# is down to 7x7x64 feature maps -- maps this to 1024 features.
with tf.name_scope('fc1'):
with tf.name_scope("fc1"):
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
@@ -167,12 +167,12 @@ def deepnn(x):
# Dropout - controls the complexity of the model, prevents co-adaptation of
# features.
with tf.name_scope('dropout'):
with tf.name_scope("dropout"):
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# Map the 1024 features to 10 classes, one for each digit
with tf.name_scope('fc2'):
with tf.name_scope("fc2"):
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
@@ -182,13 +182,13 @@ def deepnn(x):
def conv2d(x, W):
"""conv2d returns a 2d convolution layer with full stride."""
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding="SAME")
def max_pool_2x2(x):
"""max_pool_2x2 downsamples a feature map by 2X."""
return tf.nn.max_pool(
x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
def weight_variable(shape):
examples/resnet/resnet_model.py
+61 -61
View File
@@ -21,9 +21,9 @@ import ray
import ray.experimental.tf_utils
HParams = namedtuple(
'HParams', 'batch_size, num_classes, min_lrn_rate, lrn_rate, '
'num_residual_units, use_bottleneck, weight_decay_rate, '
'relu_leakiness, optimizer, num_gpus')
"HParams", "batch_size, num_classes, min_lrn_rate, lrn_rate, "
"num_residual_units, use_bottleneck, weight_decay_rate, "
"relu_leakiness, optimizer, num_gpus")
class ResNet(object):
@@ -50,7 +50,7 @@ class ResNet(object):
"""Build a whole graph for the model."""
self.global_step = tf.Variable(0, trainable=False)
self._build_model()
if self.mode == 'train':
if self.mode == "train":
self._build_train_op()
else:
# Additional initialization for the test network.
@@ -65,8 +65,8 @@ class ResNet(object):
def _build_model(self):
"""Build the core model within the graph."""
with tf.variable_scope('init'):
x = self._conv('init_conv', self._images, 3, 3, 16,
with tf.variable_scope("init"):
x = self._conv("init_conv", self._images, 3, 3, 16,
self._stride_arr(1))
strides = [1, 2, 2]
@@ -78,46 +78,46 @@ class ResNet(object):
res_func = self._residual
filters = [16, 16, 32, 64]
with tf.variable_scope('unit_1_0'):
with tf.variable_scope("unit_1_0"):
x = res_func(x, filters[0], filters[1], self._stride_arr(
strides[0]), activate_before_residual[0])
for i in range(1, self.hps.num_residual_units):
with tf.variable_scope('unit_1_%d' % i):
with tf.variable_scope("unit_1_%d" % i):
x = res_func(x, filters[1], filters[1], self._stride_arr(1),
False)
with tf.variable_scope('unit_2_0'):
with tf.variable_scope("unit_2_0"):
x = res_func(x, filters[1], filters[2], self._stride_arr(
strides[1]), activate_before_residual[1])
for i in range(1, self.hps.num_residual_units):
with tf.variable_scope('unit_2_%d' % i):
with tf.variable_scope("unit_2_%d" % i):
x = res_func(x, filters[2], filters[2], self._stride_arr(1),
False)
with tf.variable_scope('unit_3_0'):
with tf.variable_scope("unit_3_0"):
x = res_func(x, filters[2], filters[3], self._stride_arr(
strides[2]), activate_before_residual[2])
for i in range(1, self.hps.num_residual_units):
with tf.variable_scope('unit_3_%d' % i):
with tf.variable_scope("unit_3_%d" % i):
x = res_func(x, filters[3], filters[3], self._stride_arr(1),
False)
with tf.variable_scope('unit_last'):
x = self._batch_norm('final_bn', x)
with tf.variable_scope("unit_last"):
x = self._batch_norm("final_bn", x)
x = self._relu(x, self.hps.relu_leakiness)
x = self._global_avg_pool(x)
with tf.variable_scope('logit'):
with tf.variable_scope("logit"):
logits = self._fully_connected(x, self.hps.num_classes)
self.predictions = tf.nn.softmax(logits)
with tf.variable_scope('costs'):
with tf.variable_scope("costs"):
xent = tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=self.labels)
self.cost = tf.reduce_mean(xent, name='xent')
self.cost = tf.reduce_mean(xent, name="xent")
self.cost += self._decay()
if self.mode == 'eval':
tf.summary.scalar('cost', self.cost)
if self.mode == "eval":
tf.summary.scalar("cost", self.cost)
def _build_train_op(self):
"""Build training specific ops for the graph."""
@@ -127,11 +127,11 @@ class ResNet(object):
values = [0.1, 0.01, 0.001, 0.0001]
self.lrn_rate = tf.train.piecewise_constant(self.global_step,
boundaries, values)
tf.summary.scalar('learning rate', self.lrn_rate)
tf.summary.scalar("learning rate", self.lrn_rate)
if self.hps.optimizer == 'sgd':
if self.hps.optimizer == "sgd":
optimizer = tf.train.GradientDescentOptimizer(self.lrn_rate)
elif self.hps.optimizer == 'mom':
elif self.hps.optimizer == "mom":
optimizer = tf.train.MomentumOptimizer(self.lrn_rate, 0.9)
apply_op = optimizer.minimize(self.cost, global_step=self.global_step)
@@ -146,27 +146,27 @@ class ResNet(object):
params_shape = [x.get_shape()[-1]]
beta = tf.get_variable(
'beta',
"beta",
params_shape,
tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32))
gamma = tf.get_variable(
'gamma',
"gamma",
params_shape,
tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32))
if self.mode == 'train':
mean, variance = tf.nn.moments(x, [0, 1, 2], name='moments')
if self.mode == "train":
mean, variance = tf.nn.moments(x, [0, 1, 2], name="moments")
moving_mean = tf.get_variable(
'moving_mean',
"moving_mean",
params_shape,
tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32),
trainable=False)
moving_variance = tf.get_variable(
'moving_variance',
"moving_variance",
params_shape,
tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32),
@@ -180,13 +180,13 @@ class ResNet(object):
moving_variance, variance, 0.9))
else:
mean = tf.get_variable(
'moving_mean',
"moving_mean",
params_shape,
tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32),
trainable=False)
variance = tf.get_variable(
'moving_variance',
"moving_variance",
params_shape,
tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32),
@@ -208,27 +208,27 @@ class ResNet(object):
activate_before_residual=False):
"""Residual unit with 2 sub layers."""
if activate_before_residual:
with tf.variable_scope('shared_activation'):
x = self._batch_norm('init_bn', x)
with tf.variable_scope("shared_activation"):
x = self._batch_norm("init_bn", x)
x = self._relu(x, self.hps.relu_leakiness)
orig_x = x
else:
with tf.variable_scope('residual_only_activation'):
with tf.variable_scope("residual_only_activation"):
orig_x = x
x = self._batch_norm('init_bn', x)
x = self._batch_norm("init_bn", x)
x = self._relu(x, self.hps.relu_leakiness)
with tf.variable_scope('sub1'):
x = self._conv('conv1', x, 3, in_filter, out_filter, stride)
with tf.variable_scope("sub1"):
x = self._conv("conv1", x, 3, in_filter, out_filter, stride)
with tf.variable_scope('sub2'):
x = self._batch_norm('bn2', x)
with tf.variable_scope("sub2"):
x = self._batch_norm("bn2", x)
x = self._relu(x, self.hps.relu_leakiness)
x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])
x = self._conv("conv2", x, 3, out_filter, out_filter, [1, 1, 1, 1])
with tf.variable_scope('sub_add'):
with tf.variable_scope("sub_add"):
if in_filter != out_filter:
orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')
orig_x = tf.nn.avg_pool(orig_x, stride, stride, "VALID")
orig_x = tf.pad(
orig_x,
[[0, 0], [0, 0], [0, 0], [(out_filter - in_filter) // 2,
@@ -245,34 +245,34 @@ class ResNet(object):
activate_before_residual=False):
"""Bottleneck residual unit with 3 sub layers."""
if activate_before_residual:
with tf.variable_scope('common_bn_relu'):
x = self._batch_norm('init_bn', x)
with tf.variable_scope("common_bn_relu"):
x = self._batch_norm("init_bn", x)
x = self._relu(x, self.hps.relu_leakiness)
orig_x = x
else:
with tf.variable_scope('residual_bn_relu'):
with tf.variable_scope("residual_bn_relu"):
orig_x = x
x = self._batch_norm('init_bn', x)
x = self._batch_norm("init_bn", x)
x = self._relu(x, self.hps.relu_leakiness)
with tf.variable_scope('sub1'):
x = self._conv('conv1', x, 1, in_filter, out_filter / 4, stride)
with tf.variable_scope("sub1"):
x = self._conv("conv1", x, 1, in_filter, out_filter / 4, stride)
with tf.variable_scope('sub2'):
x = self._batch_norm('bn2', x)
with tf.variable_scope("sub2"):
x = self._batch_norm("bn2", x)
x = self._relu(x, self.hps.relu_leakiness)
x = self._conv('conv2', x, 3, out_filter / 4, out_filter / 4,
x = self._conv("conv2", x, 3, out_filter / 4, out_filter / 4,
[1, 1, 1, 1])
with tf.variable_scope('sub3'):
x = self._batch_norm('bn3', x)
with tf.variable_scope("sub3"):
x = self._batch_norm("bn3", x)
x = self._relu(x, self.hps.relu_leakiness)
x = self._conv('conv3', x, 1, out_filter / 4, out_filter,
x = self._conv("conv3", x, 1, out_filter / 4, out_filter,
[1, 1, 1, 1])
with tf.variable_scope('sub_add'):
with tf.variable_scope("sub_add"):
if in_filter != out_filter:
orig_x = self._conv('project', orig_x, 1, in_filter,
orig_x = self._conv("project", orig_x, 1, in_filter,
out_filter, stride)
x += orig_x
@@ -282,7 +282,7 @@ class ResNet(object):
"""L2 weight decay loss."""
costs = []
for var in tf.trainable_variables():
if var.op.name.find(r'DW') > 0:
if var.op.name.find(r"DW") > 0:
costs.append(tf.nn.l2_loss(var))
return tf.multiply(self.hps.weight_decay_rate, tf.add_n(costs))
@@ -292,24 +292,24 @@ class ResNet(object):
with tf.variable_scope(name):
n = filter_size * filter_size * out_filters
kernel = tf.get_variable(
'DW', [filter_size, filter_size, in_filters, out_filters],
"DW", [filter_size, filter_size, in_filters, out_filters],
tf.float32,
initializer=tf.random_normal_initializer(
stddev=np.sqrt(2.0 / n)))
return tf.nn.conv2d(x, kernel, strides, padding='SAME')
return tf.nn.conv2d(x, kernel, strides, padding="SAME")
def _relu(self, x, leakiness=0.0):
"""Relu, with optional leaky support."""
return tf.where(tf.less(x, 0.0), leakiness * x, x, name='leaky_relu')
return tf.where(tf.less(x, 0.0), leakiness * x, x, name="leaky_relu")
def _fully_connected(self, x, out_dim):
"""FullyConnected layer for final output."""
x = tf.reshape(x, [self.hps.batch_size, -1])
w = tf.get_variable(
'DW', [x.get_shape()[1], out_dim],
"DW", [x.get_shape()[1], out_dim],
initializer=tf.uniform_unit_scaling_initializer(factor=1.0))
b = tf.get_variable(
'biases', [out_dim], initializer=tf.constant_initializer())
"biases", [out_dim], initializer=tf.constant_initializer())
return tf.nn.xw_plus_b(x, w, b)
def _global_avg_pool(self, x):