def histogram(self, x, value_range=None, nbins=None, name=None):
"""Return histogram of values.
Given the tensor `values`, this operation returns a rank 1 histogram
counting the number of entries in `values` that fell into every bin. The
bins are equal width and determined by the arguments `value_range` and
`nbins`.
Args:
x: 1D numeric `Tensor` of items to count.
value_range: Shape [2] `Tensor`. `new_values <= value_range[0]` will be
mapped to `hist[0]`, `values >= value_range[1]` will be mapped to
`hist[-1]`. Must be same dtype as `x`.
nbins: Scalar `int32 Tensor`. Number of histogram bins.
name: Python `str` name prefixed to Ops created by this class.
Returns:
counts: 1D `Tensor` of counts, i.e.,
`counts[i] = sum{ edges[i-1] <= values[j] < edges[i] : j }`.
edges: 1D `Tensor` characterizing intervals used for counting.
"""
with tf.name_scope(name, "histogram", [x]):
x = tf.convert_to_tensor(x, name="x")
if value_range is None:
value_range = [tf.reduce_min(x), 1 + tf.reduce_max(x)]
value_range = tf.convert_to_tensor(value_range, name="value_range")
lo = value_range[0]
hi = value_range[1]
if nbins is None:
nbins = tf.to_int32(hi - lo)
delta = (hi - lo) / tf.cast(nbins, dtype=value_range.dtype.base_dtype)
edges = tf.range(
start=lo, limit=hi, delta=delta, dtype=x.dtype.base_dtype)
counts = tf.histogram_fixed_width(x, value_range=value_range, nbins=nbins)
return counts, edges
def test_multiple_random_accumulating_updates_results_in_right_dist(self):
# Accumulate the updates in a new variable. Resultant
# histogram should be uniform. Use only 3 bins because with many bins it
# would be unlikely that all would be close to 1/n. If someone ever wants
# to test that, it would be better to check that the cdf was linear.
value_range = [1.0, 4.14159]
with self.test_session() as sess:
values = tf.placeholder(tf.float32, shape=[4, 4, 4])
hist = tf.histogram_fixed_width(values,
value_range,
nbins=3,
dtype=tf.int64)
hist_accum = tf.Variable(tf.zeros_initializer([3], dtype=tf.int64))
hist_accum = hist_accum.assign_add(hist)
tf.initialize_all_variables().run()
for _ in range(100):
# Map the rv: U[0, 1] --> U[value_range[0], value_range[1]].
values_arr = (
value_range[0] +
(value_range[1] - value_range[0]) * self.rng.rand(4, 4, 4))
hist_accum_arr = sess.run(hist_accum, feed_dict={values: values_arr})
pmf = hist_accum_arr / float(hist_accum_arr.sum())
np.testing.assert_allclose(1 / 3, pmf, atol=0.02)
def test_one_update_on_constant_2d_input(self):
# Bins will be:
# (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
value_range = [0.0, 5.0]
values = [[-1.0, 0.0, 1.5], [2.0, 5.0, 15]]
expected_bin_counts = [2, 1, 1, 0, 2]
with self.test_session():
hist = tf.histogram_fixed_width(values, value_range, nbins=5)
# Hist should start "fresh" with every eval.
self.assertAllClose(expected_bin_counts, hist.eval())
self.assertAllClose(expected_bin_counts, hist.eval())
def test_empty_input_gives_all_zero_counts(self):
# Bins will be:
# (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
value_range = [0.0, 5.0]
values = []
expected_bin_counts = [0, 0, 0, 0, 0]
with self.test_session():
hist = tf.histogram_fixed_width(values, value_range, nbins=5)
# Hist should start "fresh" with every eval.
self.assertAllClose(expected_bin_counts, hist.eval())
self.assertAllClose(expected_bin_counts, hist.eval())
def test_two_updates_on_scalar_input(self):
# Bins will be:
# (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
value_range = [0.0, 5.0]
values_1 = 1.5
values_2 = 2.5
expected_bin_counts_1 = [0, 1, 0, 0, 0]
expected_bin_counts_2 = [0, 0, 1, 0, 0]
with self.test_session():
values = tf.placeholder(tf.float32, shape=[])
hist = tf.histogram_fixed_width(values, value_range, nbins=5)
# The values in hist should depend on the current feed and nothing else.
self.assertAllClose(expected_bin_counts_2, hist.eval(feed_dict={values: values_2}))
self.assertAllClose(expected_bin_counts_1, hist.eval(feed_dict={values: values_1}))
self.assertAllClose(expected_bin_counts_1, hist.eval(feed_dict={values: values_1}))
self.assertAllClose(expected_bin_counts_2, hist.eval(feed_dict={values: values_2}))
def test_two_updates_on_constant_input(self):
# Bins will be:
# (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
value_range = [0.0, 5.0]
values_1 = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]
values_2 = [1.5, 4.5, 4.5, 4.5, 0.0, 0.0]
expected_bin_counts_1 = [2, 1, 1, 0, 2]
expected_bin_counts_2 = [2, 1, 0, 0, 3]
with self.test_session():
values = tf.placeholder(tf.float32, shape=[6])
hist = tf.histogram_fixed_width(values, value_range, nbins=5)
tf.initialize_all_variables().run()
# The values in hist should depend on the current feed and nothing else.
self.assertAllClose(expected_bin_counts_1,
hist.eval(feed_dict={values: values_1}))
self.assertAllClose(expected_bin_counts_2,
hist.eval(feed_dict={values: values_2}))
self.assertAllClose(expected_bin_counts_1,
hist.eval(feed_dict={values: values_1}))
self.assertAllClose(expected_bin_counts_1,
hist.eval(feed_dict={values: values_1}))
def build_model(self):
"""Create the main ops"""
if not self.is_inference:
# create both the generator and the discriminator
# self.x is a batch of images - shape: [N, H, W, C]
# self.y is a vector of labels - shape: [N]
# sample z from a normal distribution
self.z = tf.random_normal(shape=[self.batch_size, self.z_dim], dtype=tf.float32, seed=None, name='z')
# rescale x to [0, 1]
x_reshaped = tf.reshape(self.x, shape=[self.batch_size, self.image_size, self.image_size, self.c_dim],
name='x_reshaped')
self.images = x_reshaped / 255.
# one hot encode the label - shape: [N] -> [N, self.y_dim]
self.y = tf.one_hot(self.y, self.y_dim, name='y_onehot')
# create the generator
self.G = self.generator(self.z, self.y)
# create one instance of the discriminator for real images (the input is
# images from the dataset)
self.D, self.D_logits = self.discriminator(self.images, self.y, reuse=False)
# create another instance of the discriminator for fake images (the input is
# the discriminator). Note how we are reusing variables to share weights between
# both instances of the discriminator
self.D_, self.D_logits_ = self.discriminator(self.G, self.y, reuse=True)
# aggregate losses across batch
# we are using the cross entropy loss for all these losses
d_real = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits,
labels=tf.ones_like(self.D),
name="loss_D_real")
self.d_loss_real = tf.reduce_mean(d_real)
d_fake = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_,
labels=tf.zeros_like(self.D_),
name="loss_D_fake")
self.d_loss_fake = tf.reduce_mean(d_fake)
self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2.
# the typical GAN set-up is that of a minimax game where D is trying to minimize
# its own error and G is trying to maximize D's error however note how we are flipping G labels here:
# instead of maximizing D's error, we are minimizing D's error on the 'wrong' label
# this trick helps produce a stronger gradient
g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_,
labels=tf.ones_like(self.D_),
name="loss_G")
self.g_loss = tf.reduce_mean(g_loss)
# create some summaries for debug and monitoring
self.summaries.append(histogram_summary("z", self.z))
self.summaries.append(histogram_summary("d", self.D))
self.summaries.append(histogram_summary("d_", self.D_))
self.summaries.append(image_summary("G", self.G, max_outputs=5))
self.summaries.append(image_summary("X", self.images, max_outputs=5))
self.summaries.append(histogram_summary("G_hist", self.G))
self.summaries.append(histogram_summary("X_hist", self.images))
self.summaries.append(scalar_summary("d_loss_real", self.d_loss_real))
self.summaries.append(scalar_summary("d_loss_fake", self.d_loss_fake))
self.summaries.append(scalar_summary("g_loss", self.g_loss))
self.summaries.append(scalar_summary("d_loss", self.d_loss))
# all trainable variables
t_vars = tf.trainable_variables()
# G's variables
self.g_vars = [var for var in t_vars if 'g_' in var.name]
# D's variables
self.d_vars = [var for var in t_vars if 'd_' in var.name]
# Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram
value_range = [0.0, 1.0]
nbins = 100
hist_g = tf.to_float(tf.histogram_fixed_width(self.G, value_range, nbins=nbins)) / nbins
hist_images = tf.to_float(tf.histogram_fixed_width(self.images, value_range, nbins=nbins)) / nbins
chi_square = tf.reduce_mean(tf.div(tf.square(hist_g - hist_images), hist_g + hist_images + 1e-5))
self.summaries.append(scalar_summary("chi_square", chi_square))
else:
# Create only the generator
# self.x is the conditioned latent representation - shape: [self.batch_size, 1, self.z_dim + self.y_dim]
self.x = tf.reshape(self.x, shape=[self.batch_size, self.z_dim + self.y_dim])
# extract z and y
self.y = self.x[:, self.z_dim:self.z_dim + self.y_dim]
self.z = self.x[:, :self.z_dim]
# create an instance of the generator
self.G = self.generator(self.z, self.y)
def build_train(predictions,
end_points,
y,
embedding_sizes,
shrinkage=0.06,
lambda_div=0.0,
C=25,
alpha=2.0,
beta=0.5,
initial_acts=0.5,
eta_style=False,
dtype=tf.float32,
regularization=None):
"""
Builds the boosting based training.
Args:
predictions: tensor of the embedding predictions
end_points: dictionary of endpoints of the embedding tower
y: tensor class labels
embedding_sizes: list, which indicates the size of the sub-embedding
(e.g. [96, 160, 256])
shrinkage: if you use eta_style = True, set to 1.0, otherwise keep it
small (e.g. 0.06).
lambda_div: regularization parameter.
C: parameter for binomial deviance.
alpha: parameter for binomial deviance.
dtype: data type for computations, typically tf.float32
initial_acts: 0.5 if eta_style is false, 0.0 if eta_style is true
regularization: regularization method (either activation or
adversarial)
Returns:
The training loss.
"""
shape = predictions.get_shape().as_list()
num_learners = len(embedding_sizes)
# Pairwise labels.
pairs = tf.reshape(
tf.cast(tf.equal(y[:, tf.newaxis], y[tf.newaxis, :]), dtype), [-1])
m = 1.0 * pairs + (-C * (1.0 - pairs))
W = tf.reshape((1.0 - tf.eye(shape[0], dtype=dtype)), [-1])
W = W * pairs / tf.reduce_sum(pairs) + W * \
(1.0 - pairs) / tf.reduce_sum(1.0 - pairs)
# * boosting_weights_init
boosting_weights = tf.ones(shape=(shape[0] * shape[0], ), dtype=dtype)
normed_fvecs = []
regular_fvecs = []
# L2 normalize fvecs
for i in xrange(len(embedding_sizes)):
start = int(sum(embedding_sizes[:i]))
stop = int(start + embedding_sizes[i])
fvec = tf.cast(predictions[:, start:stop], dtype)
regular_fvecs.append(fvec)
fvec = do_print(fvec, [tf.norm(fvec, axis=1)],
'fvecs_{}_norms'.format(i))
tf.summary.histogram('fvecs_{}'.format(i), fvec)
tf.summary.histogram('fvecs_{}_norm'.format(i), tf.norm(fvec, axis=1))
normed_fvecs.append(fvec /
tf.maximum(tf.constant(1e-5, dtype=dtype),
tf.norm(fvec, axis=1, keep_dims=True)))
alpha = tf.constant(alpha, dtype=dtype)
beta = tf.constant(beta, dtype=dtype)
C = tf.constant(C, dtype=dtype)
shrinkage = tf.constant(shrinkage, dtype=dtype)
loss = tf.constant(0.0, dtype=dtype)
acts = tf.constant(initial_acts, dtype=dtype)
tf.summary.histogram('boosting_weights_0', boosting_weights)
tf.summary.histogram(
'boosting_weights_0_pos',
tf.boolean_mask(boosting_weights, tf.equal(pairs, 1.0)))
tf.summary.histogram(
'boosting_weights_0_neg',
tf.boolean_mask(boosting_weights, tf.equal(pairs, 0.0)))
Ds = []
for i in xrange(len(embedding_sizes)):
fvec = normed_fvecs[i]
Ds.append(tf.matmul(fvec, tf.transpose(fvec)))
D = tf.reshape(Ds[-1], [-1])
my_act = alpha * (D - beta) * m
my_loss = tf.log(tf.exp(-my_act) + tf.constant(1.0, dtype=dtype))
tmp = (tf.reduce_sum(my_loss * boosting_weights * W) /
tf.constant(num_learners, dtype=dtype))
loss += tmp
tf.summary.scalar('learner_loss_{}'.format(i), tmp)
if eta_style:
nu = 2.0 / (1.0 + 1.0 + i)
if shrinkage != 1.0:
acts = (1.0 - nu) * acts + nu * shrinkage * D
inputs = alpha * (acts - beta) * m
booster_loss = tf.log(tf.exp(-(inputs)) + 1.0)
boosting_weights = tf.stop_gradient(
-tf.gradients(tf.reduce_sum(booster_loss), inputs)[0])
else:
acts = (1.0 - nu) * acts + nu * shrinkage * my_act
booster_loss = tf.log(tf.exp(-acts) + 1.0)
boosting_weights = tf.stop_gradient(
-tf.gradients(tf.reduce_sum(booster_loss), acts)[0])
else:
# simpler variant of the boosting algorithm.
acts += shrinkage * (D - beta) * alpha * m
booster_loss = tf.log(tf.exp(-acts) + 1.0)
cls_weight = tf.cast(1.0 * pairs + (1.0 - pairs) * 2.0,
dtype=dtype)
boosting_weights = tf.stop_gradient(
-tf.gradients(tf.reduce_sum(booster_loss), acts)[0] *
cls_weight)
tf.summary.histogram('boosting_weights_{}'.format(i + 1),
boosting_weights)
pos_weights = tf.boolean_mask(boosting_weights,
tf.equal(pairs, 1.0))
neg_weights = tf.boolean_mask(boosting_weights,
tf.equal(pairs, 0.0))
pos_bins = tf.histogram_fixed_width(
pos_weights,
(tf.constant(0.0, dtype=dtype), tf.constant(1.0, dtype=dtype)),
nbins=10)
neg_bins = tf.histogram_fixed_width(
neg_weights,
(tf.constant(0.0, dtype=dtype), tf.constant(1.0, dtype=dtype)),
nbins=10)
loss = do_print(loss, [tf.reduce_mean(booster_loss)],
'Booster loss {}'.format(i + 1))
loss = do_print(
loss, [pos_bins, neg_bins],
'Positive and negative boosting weights {}'.format(i + 1),
summarize=100)
tf.summary.histogram('boosting_weights_{}_pos'.format(i + 1),
pos_weights)
tf.summary.histogram('boosting_weights_{}_neg'.format(i + 1),
neg_weights)
tf.summary.scalar('booster_loss_{}'.format(i + 1),
tf.reduce_mean(booster_loss))
# add the independence loss
tf.summary.scalar('discriminative_loss', loss)
embedding_weights = [
v for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
if 'embedding' in v.name and 'weight' in v.name
]
if lambda_div > 0.0:
loss += REGULARIZATION_FUNCTIONS[regularization](
fvecs=normed_fvecs,
end_points=end_points,
embedding_weights=embedding_weights,
embedding_sizes=embedding_sizes,
lambda_weight=LAMBDA_WEIGHT) * lambda_div
tf.summary.scalar('loss', loss)
return loss
def build_model(self):
if not self.is_inference:
# create both the generator and the discriminator
# self.x is a batch of images - shape: [N, H, W, C]
# self.y is a vector of labels - shape: [N]
# sample z from a normal distribution
self.z = tf.random_normal(shape=[self.batch_size, self.z_dim],
dtype=tf.float32,
seed=None,
name='z')
# scale input to [-1, +1] range
self.images = (tf.reshape(self.x,
shape=[
self.batch_size, self.image_size,
self.image_size, self.c_dim
],
name='x_reshaped') - 128) / 127.
# create generator
self.G = self.generator(self.z)
# create an instance of the discriminator (real samples)
self.D, self.D_logits = self.discriminator(self.images,
reuse=False)
# create another identical instance of the discriminator (fake samples)
# NOTE: we are re-using variables here to share weights between the two
# instances of the discriminator
self.D_, self.D_logits_ = self.discriminator(self.G, reuse=True)
# we are using the cross entropy loss for all these losses
# note the use of the soft label smoothing here to prevent D from getting overly confident
# on real samples
d_real = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits,
labels=(tf.ones_like(self.D) - self.soft_label_margin),
name="loss_D_real")
self.d_loss_real = tf.reduce_mean(d_real)
d_fake = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits_,
labels=(tf.zeros_like(self.D_)),
name="loss_D_fake")
self.d_loss_fake = tf.reduce_mean(d_fake)
self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2.
# the typical GAN set-up is that of a minimax game where D is trying to minimize
# its own error and G is trying to maximize D's error however note how we are flipping G labels here:
# instead of maximizing D's error, we are minimizing D's error on the 'wrong' label
# this trick helps produce a stronger gradient
g_loss = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits_,
labels=(tf.ones_like(self.D_) + self.soft_label_margin),
name="loss_G")
self.g_loss = tf.reduce_mean(g_loss)
# debug
self.summaries.append(image_summary("G", self.G, max_outputs=3))
self.summaries.append(
image_summary("X", self.images, max_outputs=3))
self.summaries.append(histogram_summary("G_hist", self.G))
self.summaries.append(histogram_summary("X_hist", self.images))
self.summaries.append(
scalar_summary("d_loss_real", self.d_loss_real))
self.summaries.append(
scalar_summary("d_loss_fake", self.d_loss_fake))
self.summaries.append(scalar_summary("g_loss", self.g_loss))
self.summaries.append(scalar_summary("d_loss", self.d_loss))
# all trainable variables
t_vars = tf.trainable_variables()
# G variables
self.g_vars = [var for var in t_vars if 'g_' in var.name]
# D variables
self.d_vars = [var for var in t_vars if 'd_' in var.name]
# Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram
value_range = [0.0, 1.0]
nbins = 100
hist_g = tf.histogram_fixed_width(
self.G, value_range, nbins=nbins, dtype=tf.float32) / nbins
hist_images = tf.histogram_fixed_width(
self.images, value_range, nbins=nbins,
dtype=tf.float32) / nbins
chi_square = tf.reduce_mean(
tf.div(tf.square(hist_g - hist_images),
hist_g + hist_images + 1e-5))
self.summaries.append(scalar_summary("chi_square", chi_square))
else:
# Create only the generator
self.x = tf.reshape(self.x, shape=[self.batch_size, self.z_dim])
self.z = self.x[:, :self.z_dim]
self.G = self.generator(self.z)
train_prediction = tf_user_bias + tf_movie_bias
error = tf.subtract(train_prediction, tf_train_labels)
sse = tf.reduce_sum(tf.square(error))
if (NUM_FEATURES > 0):
regularization = tf.reduce_sum(
tf.square(tf_user_embeddings)) / NUM_FEATURES + tf.reduce_sum(
tf.abs(tf_movie_embeddings)) / NUM_FEATURES
else:
regularization = tf.reduce_sum(
tf.square(tf_movie_bias)) + tf.reduce_sum(tf.square(tf_user_bias))
# There's o need to regularize the biases
# + tf.reduce_sum(tf.square(tf_movie_bias))*batch_size/NUM_MOVIES + tf.reduce_sum(tf.square(tf_user_bias)) * batch_size / NUM_USERS
loss = sse + alpha * regularization
mse = sse / batch_size
optimizer = tf.train.GradientDescentOptimizer(tf_lr).minimize(loss)
histogram = tf.histogram_fixed_width(error, [-4.5, 4.5], nbins=10)
with tf.Session(graph=graph) as session:
tf.global_variables_initializer().run()
print("Initialized")
uemb, memb = session.run([user_embeddings, movie_embeddings])
print("user embeddings: {}\n", uemb)
print("movie embeddings: {}\n", memb)
acccount = acctot = 0.0
old_loss = 1e20
lr = base_lbda
for step in range(num_steps):
offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
batch_data = train_data[offset:(offset + batch_size), :]
batch_labels = train_labels[offset:(offset + batch_size), :]
feed_dict = {
def histogram(image, nbins=256, source_range='image', normalize=False):
"""Return histogram of image.
This function returns the centers of bins and does not rebin integer
arrays. For integer arrays, each integer value has
its own bin, which improves speed and intensity-resolution with self built
bincount_histogram function.
The histogram is computed on the flattened image: for color images, the
function should be used separately on each channel to obtain a histogram
for each color channel.
Parameters
----------
image : array
Input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
source_range : string, optional
'image' (default) determines the range from the input image.
'dtype' determines the range from the expected range of the images
of that data type.
normalize : bool, optional
If True, normalize the histogram by the sum of its values.
Returns
-------
hist : array
The values of the histogram.
hist_centers : array
The values at the center of the bins.
"""
sh = tf.shape(image)
if len(sh) == 3 and sh[-1] < 4:
warnings.warn("This might be a color image. The histogram will be "
"computed on the flattened image. You can instead "
"apply this function to each color channel.")
image = image.flatten() #flattern the image into 1 dimentional vector
# For integer types, histogramming with bincount is more efficient.
if image.dtype == 'int':
hist, bin_centers = _bincount_histogram(image, source_range)
else:
if source_range == 'image':
hist_range = [0.0,
256.0] #modify the historgram range as image RGB 256
elif source_range == 'dtype':
hist_range = dtype_limits(
image, clip_negative=False
) #modify the histogram range as datype case
else:
ValueError('Wrong value for the `source_range` argument')
hist_centers = [i for i in range(int(hist_range[1]))]
tensor = tf.convert_to_tensor(image, dtype=tf.float32)
hist = tf.histogram_fixed_width(tensor, hist_range, nbins)
if normalize:
hist = hist / tf.reduce_sum(hist)
return hist, hist_centers
# da_1 = tf.argmax(img_GT) # da_1 = tf.argmax(da_1) # sp_1 = img_GT.get_shape() sp_1 = tf.shape(img_GT) da_1_img = tf.reduce_max(img_GT) # xiao_1 = tf.reduce_min(img_GT) sp_2 = tf.shape(img_SM) # da_2 = tf.reduce_max(img_SM) # xiao_2 = tf.reduce_min(img_SM) nbins = 100 #256 # VALUE_RANGE = [0, 255] VALUE_RANGE = [0.0, 255.0] hist_GT = tf.histogram_fixed_width(img_GT, VALUE_RANGE, nbins) hist_SM = tf.histogram_fixed_width(img_SM, VALUE_RANGE, nbins) ##################################### # Differentiable Histogram Counting Method hist_GT_Dev = np.zeros([1, nbins]) delta = 255 / nbins BIN_Table = np.arange(0, 100, 1) BIN_Table = BIN_Table.astype(np.float64) BIN_Table = BIN_Table * delta S_total_pixels = 240 * 320 # The rows and columns of the input image # BIN_Table_2 = np.zeros([1, nbins])
def histogram(input_, value_min, value_max, nbins=None, name="histogram"):
return tf.histogram_fixed_width(input_, [value_min, value_max], nbins, name=name)
def hist(a, b):
return tf.histogram_fixed_width(tf.nn.sigmoid(
a @ tf.transpose(b)), [0.0, 1.0],
nbins=n_bins)
import tensorflow as tf
import numpy as np
import cv2
x = tf.placeholder(tf.float32,[None,None,None,3],name='x')
lowcut = tf.Variable(tf.constant(0.005),name='lowcut')
highcut = tf.Variable(tf.constant(0.001),name='highcut')
RedHist = tf.histogram_fixed_width(x[:,:,:,0],[0.0,255.0],nbins=255)
GreenHist = tf.histogram_fixed_width(x[:,:,:,1],[0.0,255.0],nbins=255)
BlueHist = tf.histogram_fixed_width(x[:,:,:,2],[0.0,255.0],nbins=255)
PixelAmount = tf.cast(tf.reduce_min([tf.reduce_sum(RedHist),tf.reduce_sum(GreenHist),
tf.reduce_sum(BlueHist)]),tf.float32)
CumRed = tf.cast(tf.cumsum(RedHist,axis=0),tf.float32)
CumGreen = tf.cast(tf.cumsum(GreenHist,axis=0),tf.float32)
CumBlue = tf.cast(tf.cumsum(BlueHist,axis=0),tf.float32)
minR = tf.where(tf.cast(tf.add(tf.subtract(CumRed,tf.multiply(PixelAmount,lowcut)),
tf.abs(tf.subtract(CumRed,tf.multiply(PixelAmount,lowcut)))),tf.bool))[0][0]
minG = tf.where(tf.cast(tf.add(tf.subtract(CumGreen,tf.multiply(PixelAmount,lowcut)),
tf.abs(tf.subtract(CumGreen,tf.multiply(PixelAmount,lowcut)))),tf.bool))[0][0]
minB = tf.where(tf.cast(tf.add(tf.subtract(CumBlue,tf.multiply(PixelAmount,lowcut)),
tf.abs(tf.subtract(CumBlue,tf.multiply(PixelAmount,lowcut)))),tf.bool))[0][0]
maxR = tf.where(tf.cast(tf.add(tf.subtract(CumRed,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))),
tf.abs(tf.subtract(CumRed,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))))),tf.bool))[0][0]
maxG = tf.where(tf.cast(tf.add(tf.subtract(CumGreen,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))),
tf.abs(tf.subtract(CumGreen,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))))),tf.bool))[0][0]
maxB = tf.where(tf.cast(tf.add(tf.subtract(CumBlue,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))),
tf.abs(tf.subtract(CumBlue,tf.multiply(PixelAmount,tf.subtract(1.0,highcut))))),tf.bool))[0][0]
def threshold_otsu(image):
"""Return threshold value based on Otsu's method. Adapted to tf from sklearn
Parameters
----------
image : (N, M) ndarray
Grayscale input image.
nbins : int, optional
Number of bins used to calculate histogram. This value is ignored for
integer arrays.
Returns
-------
threshold : float
Upper threshold value. All pixels with an intensity higher than
this value are assumed to be foreground.
Raises
------
ValueError
If ``image`` only contains a single grayscale value.
References
----------
.. [1] Wikipedia, https://en.wikipedia.org/wiki/Otsu's_Method
Examples
--------
>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_otsu(image)
>>> binary = image <= thresh
Notes
-----
The input image must be grayscale.
"""
if len(image.shape) > 2 and image.shape[-1] in (3, 4):
msg = ("threshold_otsu is expected to work correctly only for "
"grayscale images; image shape {0} looks like an RGB image")
warn(msg.format(image.shape))
# Check if the image is multi-colored or not
tf.debugging.assert_none_equal(
tf.math.reduce_min(image),
tf.math.reduce_max(image),
summarize=1,
message="expects more than one image value",
)
hist = tf.histogram_fixed_width(image, tf.constant([0, 255]), 256)
hist = tf.cast(hist, tf.float32)
bin_centers = tf.range(0.5, 256, dtype=tf.float32)
# class probabilities for all possible thresholds
weight1 = tf.cumsum(hist)
weight2 = tf.cumsum(hist, reverse=True)
# class means for all possible thresholds
mean = tf.math.multiply(hist, bin_centers)
mean1 = tf.math.divide(tf.cumsum(mean), weight1)
# mean2 = (tf.cumsum((hist * bin_centers)[::-1]) / weight2[::-1])[::-1]
mean2 = tf.math.divide(tf.cumsum(mean, reverse=True), weight2)
# Clip ends to align class 1 and class 2 variables:
# The last value of ``weight1``/``mean1`` should pair with zero values in
# ``weight2``/``mean2``, which do not exist.
tmp1 = tf.math.multiply(weight1[:-1], weight2[1:])
tmp2 = (mean1[:-1] - mean2[1:])**2
variance12 = tf.math.multiply(tmp1, tmp2)
idx = tf.math.argmax(variance12)
threshold = bin_centers[:-1][idx]
return threshold
def build_model(self):
if not self.is_inference:
# create both the generator and the discriminator
# self.x is a batch of images - shape: [N, H, W, C]
# self.y is a vector of labels - shape: [N]
# sample z from a normal distribution
self.z = tf.random_normal(shape=[self.batch_size, self.z_dim], dtype=tf.float32, seed=None, name='z')
# scale input to [-1, +1] range
self.images = (tf.reshape(self.x,
shape=[self.batch_size,
self.image_size,
self.image_size,
self.c_dim],
name='x_reshaped') - 128) / 127.
# create generator
self.G = self.generator(self.z)
# create an instance of the discriminator (real samples)
self.D, self.D_logits = self.discriminator(self.images, reuse=False)
# create another identical instance of the discriminator (fake samples)
# NOTE: we are re-using variables here to share weights between the two
# instances of the discriminator
self.D_, self.D_logits_ = self.discriminator(self.G, reuse=True)
# we are using the cross entropy loss for all these losses
# note the use of the soft label smoothing here to prevent D from getting overly confident
# on real samples
d_real = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits,
labels=(tf.ones_like(self.D) - self.soft_label_margin),
name="loss_D_real")
self.d_loss_real = tf.reduce_mean(d_real)
d_fake = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_,
labels=(tf.zeros_like(self.D_)),
name="loss_D_fake")
self.d_loss_fake = tf.reduce_mean(d_fake)
self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2.
# the typical GAN set-up is that of a minimax game where D is trying to minimize
# its own error and G is trying to maximize D's error however note how we are flipping G labels here:
# instead of maximizing D's error, we are minimizing D's error on the 'wrong' label
# this trick helps produce a stronger gradient
g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_,
labels=(tf.ones_like(self.D_) + self.soft_label_margin),
name="loss_G")
self.g_loss = tf.reduce_mean(g_loss)
# debug
self.summaries.append(image_summary("G", self.G, max_outputs=3))
self.summaries.append(image_summary("X", self.images, max_outputs=3))
self.summaries.append(histogram_summary("G_hist", self.G))
self.summaries.append(histogram_summary("X_hist", self.images))
self.summaries.append(scalar_summary("d_loss_real", self.d_loss_real))
self.summaries.append(scalar_summary("d_loss_fake", self.d_loss_fake))
self.summaries.append(scalar_summary("g_loss", self.g_loss))
self.summaries.append(scalar_summary("d_loss", self.d_loss))
# all trainable variables
t_vars = tf.trainable_variables()
# G variables
self.g_vars = [var for var in t_vars if 'g_' in var.name]
# D variables
self.d_vars = [var for var in t_vars if 'd_' in var.name]
# Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram
value_range = [0.0, 1.0]
nbins = 100
hist_g = tf.histogram_fixed_width(self.G, value_range, nbins=nbins, dtype=tf.float32) / nbins
hist_images = tf.histogram_fixed_width(self.images, value_range, nbins=nbins, dtype=tf.float32) / nbins
chi_square = tf.reduce_mean(tf.div(tf.square(hist_g - hist_images), hist_g + hist_images + 1e-5))
self.summaries.append(scalar_summary("chi_square", chi_square))
else:
# Create only the generator
self.x = tf.reshape(self.x, shape=[self.batch_size, self.z_dim])
self.z = self.x[:, :self.z_dim]
self.G = self.generator(self.z)
def calc_histogram(image):
values_range = tf.constant([0, 255], dtype=tf.float32)
histogram = tf.histogram_fixed_width(tf.to_float(image), values_range, 256)
return histogram
def histogram(tensor, value_range=[0.0, 1.0], nbins=100):
"""Return histogram of tensor"""
h, w, c = tensor.shape
hist = tf.histogram_fixed_width(tensor, value_range, nbins=nbins)
hist = tf.divide(hist, h * w * c)
return hist
def loop_body(i, hist):
h = tf.histogram_fixed_width(t[i, :], [0.0, 10.0], nbins=shape_s)
return i + 1, tf.concat([hist, tf.expand_dims(h, 0)], axis=0)
def color_histogram(self, superpixel):
values = tf.reduce_sum(superpixel * (16777216., 65536., 256.), axis=-1)
histogram = tf.histogram_fixed_width(values, (0, 16777216.),
256, tf.float32)
return histogram
def build_model(self):
"""Create the main ops"""
if not self.is_inference:
# create both the generator and the discriminator
# self.x is a batch of images - shape: [N, H, W, C]
# self.y is a vector of labels - shape: [N]
# sample z from a normal distribution
self.z = tf.random_normal(shape=[self.batch_size, self.z_dim],
dtype=tf.float32,
seed=None,
name='z')
# rescale x to [0, 1]
x_reshaped = tf.reshape(self.x,
shape=[
self.batch_size, self.image_size,
self.image_size, self.c_dim
],
name='x_reshaped')
self.images = x_reshaped / 255.
# one hot encode the label - shape: [N] -> [N, self.y_dim]
self.y = tf.one_hot(self.y, self.y_dim, name='y_onehot')
# create the generator
self.G = self.generator(self.z, self.y)
# create one instance of the discriminator for real images (the input is
# images from the dataset)
self.D, self.D_logits = self.discriminator(self.images,
self.y,
reuse=False)
# create another instance of the discriminator for fake images (the input is
# the discriminator). Note how we are reusing variables to share weights between
# both instances of the discriminator
self.D_, self.D_logits_ = self.discriminator(self.G,
self.y,
reuse=True)
# aggregate losses across batch
# we are using the cross entropy loss for all these losses
d_real = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits,
labels=tf.ones_like(self.D),
name="loss_D_real")
self.d_loss_real = tf.reduce_mean(d_real)
d_fake = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits_,
labels=tf.zeros_like(self.D_),
name="loss_D_fake")
self.d_loss_fake = tf.reduce_mean(d_fake)
self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2.
# the typical GAN set-up is that of a minimax game where D is trying to minimize
# its own error and G is trying to maximize D's error however note how we are flipping G labels here:
# instead of maximizing D's error, we are minimizing D's error on the 'wrong' label
# this trick helps produce a stronger gradient
g_loss = tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.D_logits_,
labels=tf.ones_like(self.D_),
name="loss_G")
self.g_loss = tf.reduce_mean(g_loss)
# create some summaries for debug and monitoring
self.summaries.append(histogram_summary("z", self.z))
self.summaries.append(histogram_summary("d", self.D))
self.summaries.append(histogram_summary("d_", self.D_))
self.summaries.append(image_summary("G", self.G, max_outputs=5))
self.summaries.append(
image_summary("X", self.images, max_outputs=5))
self.summaries.append(histogram_summary("G_hist", self.G))
self.summaries.append(histogram_summary("X_hist", self.images))
self.summaries.append(
scalar_summary("d_loss_real", self.d_loss_real))
self.summaries.append(
scalar_summary("d_loss_fake", self.d_loss_fake))
self.summaries.append(scalar_summary("g_loss", self.g_loss))
self.summaries.append(scalar_summary("d_loss", self.d_loss))
# all trainable variables
t_vars = tf.trainable_variables()
# G's variables
self.g_vars = [var for var in t_vars if 'g_' in var.name]
# D's variables
self.d_vars = [var for var in t_vars if 'd_' in var.name]
# Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram
value_range = [0.0, 1.0]
nbins = 100
hist_g = tf.histogram_fixed_width(
self.G, value_range, nbins=nbins, dtype=tf.float32) / nbins
hist_images = tf.histogram_fixed_width(
self.images, value_range, nbins=nbins,
dtype=tf.float32) / nbins
chi_square = tf.reduce_mean(
tf.div(tf.square(hist_g - hist_images),
hist_g + hist_images + 1e-5))
self.summaries.append(scalar_summary("chi_square", chi_square))
else:
# Create only the generator
# self.x is the conditioned latent representation - shape: [self.batch_size, 1, self.z_dim + self.y_dim]
self.x = tf.reshape(
self.x, shape=[self.batch_size, self.z_dim + self.y_dim])
# extract z and y
self.y = self.x[:, self.z_dim:self.z_dim + self.y_dim]
self.z = self.x[:, :self.z_dim]
# create an instance of the generator
self.G = self.generator(self.z, self.y)
def one_histogram(accumulator, element):
hist = tf.histogram_fixed_width(data, element, num_bins)
return tf.add(accumulator, hist)
