本文整理汇总了Python中tensorflow.keras.backend.log方法的典型用法代码示例。如果您正苦于以下问题:Python backend.log方法的具体用法?Python backend.log怎么用?Python backend.log使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类tensorflow.keras.backend
的用法示例。
在下文中一共展示了backend.log方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: amplitude_to_decibel
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def amplitude_to_decibel(x, amin=1e-10, dynamic_range=80.0):
"""[K] Convert (linear) amplitude to decibel (log10(x)).
Parameters
----------
x: Keras *batch* tensor or variable. It has to be batch because of sample-wise `K.max()`.
amin: minimum amplitude. amplitude smaller than `amin` is set to this.
dynamic_range: dynamic_range in decibel
"""
log_spec = 10 * K.log(K.maximum(x, amin)) / np.log(10).astype(K.floatx())
if K.ndim(x) > 1:
axis = tuple(range(K.ndim(x))[1:])
else:
axis = None
log_spec = log_spec - K.max(log_spec, axis=axis, keepdims=True) # [-?, 0]
log_spec = K.maximum(log_spec, -1 * dynamic_range) # [-80, 0]
return log_spec
示例2: focal_loss_binary
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def focal_loss_binary(y_true, y_pred):
"""Binary cross-entropy focal loss
"""
gamma = 2.0
alpha = 0.25
pt_1 = tf.where(tf.equal(y_true, 1),
y_pred,
tf.ones_like(y_pred))
pt_0 = tf.where(tf.equal(y_true, 0),
y_pred,
tf.zeros_like(y_pred))
epsilon = K.epsilon()
# clip to prevent NaN and Inf
pt_1 = K.clip(pt_1, epsilon, 1. - epsilon)
pt_0 = K.clip(pt_0, epsilon, 1. - epsilon)
weight = alpha * K.pow(1. - pt_1, gamma)
fl1 = -K.sum(weight * K.log(pt_1))
weight = (1 - alpha) * K.pow(pt_0, gamma)
fl0 = -K.sum(weight * K.log(1. - pt_0))
return fl1 + fl0
示例3: focal_loss_categorical
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def focal_loss_categorical(y_true, y_pred):
"""Categorical cross-entropy focal loss"""
gamma = 2.0
alpha = 0.25
# scale to ensure sum of prob is 1.0
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
# clip the prediction value to prevent NaN and Inf
epsilon = K.epsilon()
y_pred = K.clip(y_pred, epsilon, 1. - epsilon)
# calculate cross entropy
cross_entropy = -y_true * K.log(y_pred)
# calculate focal loss
weight = alpha * K.pow(1 - y_pred, gamma)
cross_entropy *= weight
return K.sum(cross_entropy, axis=-1)
示例4: mi_loss
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def mi_loss(self, y_true, y_pred):
""" MINE loss function
Arguments:
y_true (tensor): Not used since this is
unsupervised learning
y_pred (tensor): stack of predictions for
joint T(x,y) and marginal T(x,y)
"""
size = self.args.batch_size
# lower half is pred for joint dist
pred_xy = y_pred[0: size, :]
# upper half is pred for marginal dist
pred_x_y = y_pred[size : y_pred.shape[0], :]
loss = K.mean(K.exp(pred_x_y))
loss = K.clip(loss, K.epsilon(), np.finfo(float).max)
loss = K.mean(pred_xy) - K.log(loss)
return -loss
示例5: surv_likelihood
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def surv_likelihood(n_intervals):
"""Create custom Keras loss function for neural network survival model.
Arguments
n_intervals: the number of survival time intervals
Returns
Custom loss function that can be used with Keras
"""
def loss(y_true, y_pred):
"""
Required to have only 2 arguments by Keras.
Arguments
y_true: Tensor.
First half of the values is 1 if individual survived that interval, 0 if not.
Second half of the values is for individuals who failed, and is 1 for time interval during which failure occured, 0 for other intervals.
See make_surv_array function.
y_pred: Tensor, predicted survival probability (1-hazard probability) for each time interval.
Returns
Vector of losses for this minibatch.
"""
cens_uncens = 1. + y_true[:,0:n_intervals] * (y_pred-1.) #component for all individuals
uncens = 1. - y_true[:,n_intervals:2*n_intervals] * y_pred #component for only uncensored individuals
return K.sum(-K.log(K.clip(K.concatenate((cens_uncens,uncens)),K.epsilon(),None)),axis=-1) #return -log likelihood
return loss
示例6: convert_log
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def convert_log(node, params, layers, lambda_func, node_name, keras_name):
"""
Convert Log layer
:param node: current operation node
:param params: operation attributes
:param layers: available keras layers
:param lambda_func: function for keras Lambda layer
:param node_name: internal converter name
:param keras_name: resulting layer name
:return: None
"""
if len(node.input) != 1:
assert AttributeError('More than 1 input for log layer.')
input_0 = ensure_tf_type(layers[node.input[0]], name="%s_const" % keras_name)
def target_layer(x):
import tensorflow.keras.backend as K
return K.log(x)
lambda_layer = keras.layers.Lambda(target_layer, name=keras_name)
layers[node_name] = lambda_layer(input_0)
lambda_func[keras_name] = target_layer
示例7: convert_exp
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def convert_exp(node, params, layers, lambda_func, node_name, keras_name):
"""
Convert Exp layer
:param node: current operation node
:param params: operation attributes
:param layers: available keras layers
:param lambda_func: function for keras Lambda layer
:param node_name: resulting layer name
:return: None
"""
if len(node.input) != 1:
assert AttributeError('More than 1 input for log layer.')
input_0 = ensure_tf_type(layers[node.input[0]], name="%s_const" % keras_name)
def target_layer(x):
import tensorflow.keras.backend as K
return K.exp(x)
lambda_layer = keras.layers.Lambda(target_layer, name=keras_name)
layers[node_name] = lambda_layer(input_0)
lambda_func[keras_name] = target_layer
示例8: loss
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def loss(self, y_true, y_pred):
""" categorical crossentropy loss """
if self.crop_indices is not None:
y_true = utils.batch_gather(y_true, self.crop_indices)
y_pred = utils.batch_gather(y_pred, self.crop_indices)
if self.use_float16:
y_true = K.cast(y_true, 'float16')
y_pred = K.cast(y_pred, 'float16')
# scale and clip probabilities
# this should not be necessary for softmax output.
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1)
# compute log probability
log_post = K.log(y_pred) # likelihood
# loss
loss = - y_true * log_post
# weighted loss
if self.weights is not None:
loss *= self.weights
if self.vox_weights is not None:
loss *= self.vox_weights
# take the total loss
# loss = K.batch_flatten(loss)
mloss = K.mean(K.sum(K.cast(loss, 'float32'), -1))
tf.verify_tensor_all_finite(mloss, 'Loss not finite')
return mloss
示例9: logtanh
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def logtanh(x, a=1):
"""
log * tanh
See Also: arcsinh
"""
return K.tanh(x) * K.log(2 + a * abs(x))
示例10: customLoss
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def customLoss(y_true,y_pred):
log1 = 1.5 * y_true * K.log(y_pred + 1e-9) * K.pow(1-y_pred, 2)
log0 = 0.5 * (1 - y_true) * K.log((1 - y_pred) + 1e-9) * K.pow(y_pred, 2)
return (- K.sum(K.mean(log0 + log1, axis = 0)))
示例11: _get_scale
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def _get_scale(alpha, x, q):
"""Gets scaling factor for scaling the tensor per channel.
Arguments:
alpha: A float or string. When it is string, it should be either "auto" or
"auto_po2", and
scale = sum(x * q, axis=all but last) / sum(q * q, axis=all but last)
x: A tensor object. Its elements are in float.
q: A tensor object. Its elements are in quantized format of x.
Returns:
A scaling factor tensor or scala for scaling tensor per channel.
"""
if isinstance(alpha, six.string_types) and "auto" in alpha:
assert alpha in ["auto", "auto_po2"]
x_shape = x.shape.as_list()
len_axis = len(x_shape)
if len_axis > 1:
if K.image_data_format() == "channels_last":
axis = list(range(len_axis - 1))
else:
axis = list(range(1, len_axis))
qx = K.mean(tf.math.multiply(x, q), axis=axis, keepdims=True)
qq = K.mean(tf.math.multiply(q, q), axis=axis, keepdims=True)
else:
qx = K.mean(x * q, axis=0, keepdims=True)
qq = K.mean(q * q, axis=0, keepdims=True)
scale = qx / (qq + K.epsilon())
if alpha == "auto_po2":
scale = K.pow(2.0,
tf.math.round(K.log(scale + K.epsilon()) / np.log(2.0)))
elif alpha is None:
scale = 1.0
elif isinstance(alpha, np.ndarray):
scale = alpha
else:
scale = float(alpha)
return scale
示例12: stochastic_round_po2
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def stochastic_round_po2(x):
"""Performs stochastic rounding for the power of two."""
# TODO(hzhuang): test stochastic_round_po2 and constraint.
# because quantizer is applied after constraint.
y = tf.abs(x)
eps = tf.keras.backend.epsilon()
log2 = tf.keras.backend.log(2.0)
x_log2 = tf.round(tf.keras.backend.log(y + eps) / log2)
po2 = tf.cast(pow(2.0, tf.cast(x_log2, dtype="float32")), dtype="float32")
left_val = tf.where(po2 > y, x_log2 - 1, x_log2)
right_val = tf.where(po2 > y, x_log2, x_log2 + 1)
# sampling in [2**left_val, 2**right_val].
minval = 2 ** left_val
maxval = 2 ** right_val
val = tf.random.uniform(tf.shape(y), minval=minval, maxval=maxval)
# use y as a threshold to keep the probabliy [2**left_val, y, 2**right_val]
# so that the mean value of the sample should be y
x_po2 = tf.where(y < val, left_val, right_val)
"""
x_log2 = stochastic_round(tf.keras.backend.log(y + eps) / log2)
sign = tf.sign(x)
po2 = (
tf.sign(x) *
tf.cast(pow(2.0, tf.cast(x_log2, dtype="float32")), dtype="float32")
)
"""
return x_po2
示例13: __call__
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def __call__(self, x):
non_sign_bits = self.bits - 1
m = pow(2, non_sign_bits)
m_i = pow(2, self.integer)
p = _sigmoid(x / m_i) * m
rp = 2.0 * (_round_through(p) / m) - 1.0
u_law_p = tf.sign(rp) * tf.keras.backend.log(
1 + self.u * tf.abs(rp)) / tf.keras.backend.log(1 + self.u)
xq = m_i * tf.keras.backend.clip(u_law_p, -1.0 +
(1.0 * self.symmetric) / m, 1.0 - 1.0 / m)
return xq
示例14: _need_exponent_sign_bit_check
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def _need_exponent_sign_bit_check(max_value):
"""Checks whether the sign bit of exponent is needed.
This is used by quantized_po2 and quantized_relu_po2.
Args:
max_value: the maximum value allowed.
Returns:
An integer. 1: sign_bit is needed. 0: sign_bit is not needed.
"""
if max_value is not None:
if max_value < 0:
raise ValueError("po2 max_value should be non-negative.")
if max_value > 1:
# if max_value is larger than 1,
# the exponent could be positive and negative.
# e.g., log(max_value) > 0 when max_value > 1
need_exponent_sign_bit = 1
else:
need_exponent_sign_bit = 0
else:
# max_value is not specified, so we cannot decide the range.
# Then we need to put sign_bit for exponent to be safe
need_exponent_sign_bit = 1
return need_exponent_sign_bit
示例15: mi_loss
# 需要导入模块: from tensorflow.keras import backend [as 别名]
# 或者: from tensorflow.keras.backend import log [as 别名]
def mi_loss(c, q_of_c_given_x):
""" Mutual information, Equation 5 in [2],
assuming H(c) is constant
"""
# mi_loss = -c * log(Q(c|x))
return -K.mean(K.sum(c * K.log(q_of_c_given_x + K.epsilon()),
axis=1))