我们从Python开源项目中，提取了以下20个代码示例，用于说明如何使用tensorflow.round()。
def resample(patient, new_spacing=[1,1,1]): scan = get_scan(patient) image = get_3D_data(patient) # Determine current pixel spacing spacing = np.array([scan[0].SliceThickness] + scan[0].PixelSpacing, dtype=np.float32) resize_factor = spacing / new_spacing new_real_shape = image.shape * resize_factor new_shape = np.round(new_real_shape) real_resize_factor = new_shape / image.shape new_spacing = spacing / real_resize_factor image = nd.interpolation.zoom(image, real_resize_factor, mode='nearest') return image # For the sake of testing the network, we'll be using the sample dataset # For this, we'll use the maximum size of the image # and PAD any image with -1000 values which is smaller than that #PS: only the first dimension is different in sample dataset #which is not the case in actual dataset
def sample_output(self, val): vocabulary = self.get_vocabulary() if self.one_hot: vals = [ np.argmax(r) for r in val ] ox_val = [vocabulary[obj] for obj in list(vals)] string = "".join(ox_val) return string else: val = np.reshape(val, [-1]) val *= len(vocabulary)/2.0 val += len(vocabulary)/2.0 val = np.round(val) val = np.maximum(0, val) val = np.minimum(len(vocabulary)-1, val) ox_val = [self.get_character(obj) for obj in list(val)] string = "".join(ox_val) return string
def _bbox_to_mask(yy, region_size, dtype): # trim bounding box exeeding region_size on top and left neg_part = tf.nn.relu(-yy[:2]) core = tf.ones(tf.to_int32(tf.round(yy[2:] - neg_part)), dtype=dtype) y1 = tf.maximum(yy[0], 0.) x1 = tf.maximum(yy[1], 0.) y2 = tf.minimum(region_size[0], yy[0] + yy[2]) x2 = tf.minimum(region_size[1], yy[1] + yy[3]) padding = (y1, region_size[0] - y2, x1, region_size[1] - x2) padding = tf.reshape(tf.stack(padding), (-1, 2)) padding = tf.to_int32(tf.round(padding)) mask = tf.pad(core, padding) # trim bounding box exeeding region_size on bottom and right rs = tf.to_int32(tf.round(region_size)) mask = mask[:rs[0], :rs[1]] mask.set_shape((None, None)) return mask
def get_masks(origin_images, height, width, channels=3): """add horizon color lines and set empty""" quarty = tf.random_uniform([height/4, 1]) prop = tf.scalar_mul(tf.convert_to_tensor(0.2), tf.ones([height/4, 1])) quarty = tf.round(tf.add(quarty, prop)) y = tf.reshape(tf.stack([quarty, quarty, quarty, quarty], axis=1), [height, 1]) mask = tf.matmul(y, tf.ones([1, width])) masks = tf.expand_dims(mask, 0) masks = tf.expand_dims(masks, -1) maskedimages = tf.mul(origin_images, masks) """add noise""" scale = tf.random_uniform([channels, height, 1]) y = tf.subtract(tf.ones([height, 1]), y) y = tf.expand_dims(y, 0) y = tf.scalar_mul(tf.convert_to_tensor(255.), tf.multiply(scale, y)) noise = tf.add(mask, tf.matmul(y, tf.ones([channels, 1, width]))) noise = tf.pack(tf.split(value=noise, num_or_size_splits=noise.get_shape()[0], axis=0), axis=3) maskedimages = tf.add(maskedimages, noise) return maskedimages
def sim_occlusions(poses, dm_shape, batch_size, max_length, n_dims, body_splits, _int_type=tf.int32, _float_type=tf.float32): def occluded_poses(): body_splits_tf = tf.constant(body_splits, dtype=_int_type) occ_idcs = tf.random_uniform([batch_size, 1], minval=0, maxval=len(body_splits), dtype=_int_type) occ_idcs = tf.gather_nd(body_splits_tf, occ_idcs) noise_mask = tf.tile( tf.reshape( tf.cast(tf.reduce_sum(tf.one_hot(occ_idcs, dm_shape[0]), axis=1), dtype=tf.bool), [batch_size, 1, dm_shape[0], 1]), [1, max_length, 1, n_dims]) noisy_poses = poses * tf.random_uniform([batch_size, max_length, 1, n_dims], minval=0.8, maxval=1.2, dtype=_float_type) return tf.where(noise_mask, noisy_poses, poses) occlude_rate = 0.5 return tf.cond(tf.cast(tf.round(tf.random_uniform([], minval=-0.5, maxval=0.5) + occlude_rate), tf.bool), occluded_poses, lambda: poses)
def _binary_round(x): """ Rounds a tensor whose values are in [0,1] to a tensor with values in {0, 1}, using the straight through estimator for the gradient. Based on http://r2rt.com/binary-stochastic-neurons-in-tensorflow.html :param x: input tensor :return: y=round(x) with gradients defined by the identity mapping (y=x) """ g = tf.get_default_graph() with ops.name_scope("BinaryRound") as name: with g.gradient_override_map({"Round": "Identity"}): return tf.round(x, name=name)
def mode(self): return tf.round(self.ps)
def glimpseSensor(normalLocation, inputPlaceholder): location = tf.round(tf.multiply((normalLocation + 1)/2.0, InputImageSize)) location = tf.cast(location, tf.int32) images = tf.reshape(inputPlaceholder, (batchSize, InputImageSize[0], InputImageSize[1], InputImageSize[2])) zooms = [] for k in xrange(batchSize): imgZooms = [] img = images[k] loc = location[k] for i in xrange(glimpseDepth): radius = int(glimpseRadius * (2 ** i)) glimpse = getGlipmse(img, loc, radius) glimpse = tf.reshape(glimpse, (glimpseBandwidth, glimpseBandwidth, glimpseBandwidth)) imgZooms.append(glimpse) zooms.append(tf.pack(imgZooms)) zooms = tf.pack(zooms) return zooms
def binary_accuracy(y_true, y_pred, mask=1): round_y_pred = tf.round(y_pred) right_cnt = tf.cast(tf.equal(y_true, round_y_pred), tf.float32) return compute_weighted_loss(right_cnt, mask)
def round(x): '''Element-wise rounding to the closest integer. ''' return tf.round(x)
def modal(config, gan, net): net = tf.round(net*float(config.modes))/float(config.modes) return net
def __init__(self, args): with tf.device(args.device): def circle(x): spherenet = tf.square(x) spherenet = tf.reduce_sum(spherenet, 1) lam = tf.sqrt(spherenet) return x/tf.reshape(lam,[int(lam.get_shape()[0]), 1]) def modes(x): return tf.round(x*2)/2.0 if args.distribution == 'circle': x = tf.random_normal([args.batch_size, 2]) x = circle(x) elif args.distribution == 'modes': x = tf.random_uniform([args.batch_size, 2], -1, 1) x = modes(x) elif args.distribution == 'sin': x = tf.random_uniform((1, args.batch_size), -10.5, 10.5 ) x = tf.transpose(x) r_data = tf.random_normal((args.batch_size,1), mean=0, stddev=0.1) xy = tf.sin(0.75*x)*7.0+x*0.5+r_data*1.0 x = tf.concat([xy,x], 1)/16.0 elif args.distribution == 'arch': offset1 = tf.random_uniform((1, args.batch_size), -10, 10 ) xa = tf.random_uniform((1, 1), 1, 4 ) xb = tf.random_uniform((1, 1), 1, 4 ) x1 = tf.random_uniform((1, args.batch_size), -1, 1 ) xcos = tf.cos(x1*np.pi + offset1)*xa xsin = tf.sin(x1*np.pi + offset1)*xb x = tf.transpose(tf.concat([xcos,xsin], 0))/16.0 self.x = x self.xy = tf.zeros_like(self.x)
def quantize_weight(W, precision=weight_quantization): ''' For a given weight matrix, returns weights of values -1, 0 or 1 :param W: :return: ''' W_ = tf.round(W * precision) / precision return W_ ########## Loading the dataset
def fnn_model_fn(features,labels,mode): print(features) print(labels) # output_labels = tf.reshape(labels,[-1,1]) dense = tf.layers.dense(features,units=nhidden,activation=tf.nn.relu,use_bias=True) print(dense) logits = tf.layers.dense(dense,units=1,use_bias=True) print(logits) onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=1) if mode != learn.ModeKeys.EVAL: # loss = tf.losses.sigmoid_cross_entropy(output_labels,logits) # loss = tf.losses.mean_squared_error(labels=output_labels,predictions=logits) loss = tf.losses.softmax_cross_entropy( onehot_labels=onehot_labels, logits=logits) if mode==learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=learning_rate, optimizer="SGD") predictions = { "classes": tf.round(logits), "probabilities": tf.nn.softmax( logits, name="softmax_tensor") } return model_fn.ModelFnOps( mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def f_segm_match(iou, s_gt): """Matching between segmentation output and groundtruth. Args: y_out: [B, T, H, W], output segmentations y_gt: [B, T, H, W], groundtruth segmentations s_gt: [B, T], groudtruth score sequence """ global hungarian_module if hungarian_module is None: mod_name = './hungarian.so' hungarian_module = tf.load_op_library(mod_name) log.info('Loaded library "{}"'.format(mod_name)) # Mask X, [B, M] => [B, 1, M] mask_x = tf.expand_dims(s_gt, dim=1) # Mask Y, [B, M] => [B, N, 1] mask_y = tf.expand_dims(s_gt, dim=2) iou_mask = iou * mask_x * mask_y # Keep certain precision so that we can get optimal matching within # reasonable time. eps = 1e-5 precision = 1e6 iou_mask = tf.round(iou_mask * precision) / precision match_eps = hungarian_module.hungarian(iou_mask + eps)[0] # [1, N, 1, 1] s_gt_shape = tf.shape(s_gt) num_segm_out = s_gt_shape[1] num_segm_out_mul = tf.pack([1, num_segm_out, 1]) # Mask the graph algorithm output. match = match_eps * mask_x * mask_y return match
