连续变量的交叉熵通常在机器学习中的回归问题中使用，但它也可以用于分类问题，当概率分布是连续的时。连续变量的交叉熵计算公式如下：
设 \( p(x) \) 是真实概率密度函数，\( q(x) \) 是预测概率密度函数，交叉熵 \( H(p, q) \) 定义为：
\[
H(p, q) = -\int_{-\infty}^{\infty} p(x) \log q(x) \, dx
\]
在分类问题中，如果我们有 \( K \) 个类别，并且 \( p_k \) 是第 \( k \) 个类别的真实概率，\( q_k \) 是第 \( k \) 个类别的预测概率，交叉熵可以表示为：
\[
H(p, q) = -\sum_{k=1}^{K} p_k \log q_k
\]
在实际应用中，如果 \( p_k \) 是一个独热编码的向量（即只有一个类别是 1，其余都是 0），上述公式简化为：
\[
H(p, q) = -\log q_y
\]
其中 \( y \) 是真实类别的索引。
在回归问题中，如果我们有一个连续的目标变量，我们可以使用均方误差（MSE）或均方对数误差（MSLE）等其他损失函数，而不是交叉熵。然而，如果我们想要使用交叉熵，我们通常需要将问题转换为类似于分类问题的形式，例如通过将连续变量离散化或使用概率分布来建模连续变量。
下面是用梯度惩罚来实现 K L 散度最小化的实现，和交叉熵原理差不多
# 定义计算损失的函数
def compute_loss(real_data):
# 梯度惩罚权重
gradient_penalty_weight = gradient_penalty_weight_lamda
# x = tf.random.normal((batch_size, n), dtype=tf.dtypes.float32)
# x_samp = x / tf.sqrt(2 * tf.reduce_mean(tf.square(x)))
# x_gen = tf.concat(values=[w_generator(x_samp), x_samp], axis=1)
# x = X_train
# x_samp = X_train_samp
x_samp = X_train
# todo
# 计算损失函数的时候 ，用z_score归一化计算？
# todo
# x_gen = w_generator(x_samp) + x_samp
x_gen = w_generator(x_samp)
logits_x = w_discriminator(tf.concat([y_train, X_train], axis=-1))
logits_x_gen = w_discriminator(tf.concat([x_gen, X_train], axis=-1))
d_regularizer = gradient_penalty(real_data, x_gen)
disc_loss = (tf.reduce_mean(logits_x) - tf.reduce_mean(logits_x_gen) + d_regularizer * gradient_penalty_weight)
gen_loss = tf.reduce_mean(logits_x_gen)
return disc_loss, gen_loss
# 定义应用生成器梯度的函数
def apply_gen_gradients(gen_gradients):
w_gen_optimizer.apply_gradients(zip(gen_gradients, w_generator.trainable_variables))
# 定义应用判别器梯度的函数
def apply_disc_gradients(disc_gradients):
w_disc_optimizer.apply_gradients(zip(disc_gradients, w_discriminator.trainable_variables))
# 定义梯度惩罚函数
# def gradient_penalty(x, x_gen):
# epsilon = tf.random.uniform([x.shape[0], 1, 1, 1], 0.0, 1.0)
# x_hat = epsilon * x + (1 - epsilon) * x_gen
# with tf.GradientTape() as t:
# t.watch(x_hat)
# d_hat = w_discriminator(x_hat)
# gradients = t.gradient(d_hat, x_hat)
# ddx = tf.sqrt(tf.reduce_sum(gradients ** 2, axis=[1, 2]))
# d_regularizer = tf.reduce_mean((ddx - 1.0) ** 2)
# return d_regularizer
# 定义梯度惩罚函数
def gradient_penalty(x, x_gen):
# 创建一个与真实样本 x 的批量大小相同的随机变量 epsilon，其值在0和1之间，用于在后续步骤中进行插值。
# epsilon = tf.random.uniform([x.shape[0], 1, 1, 1], 0.0, 1.0)
epsilon = tf.random.uniform([x.shape[0], 1], 0.0, 1.0)
# 计算插值样本 x_hat，它是真实样本 x 和生成样本 x_gen 的线性组合。
# 这一步是为了在真实样本和生成样本之间创建一个连续的路径
x_hat = epsilon * x + (1 - epsilon) * x_gen
# print("Shape before discriminator:", x_hat.shape)
# 创建一个 tf.GradientTape 上下文，用于记录对 x_hat 的操作，以便后续计算梯度。
with tf.GradientTape() as t:
# 告诉 tf.GradientTape 监控 x_hat，以便可以计算关于它的梯度
t.watch(x_hat)
# 使用判别器 w_discriminator 对插值样本 x_hat 进行评分，得到 d_hat。
# print(x_hat.shape)
d_hat = w_discriminator(tf.concat([x_hat, X_train], axis=-1))
# 计算判别器输出 d_hat 关于插值样本 x_hat 的梯度
gradients = t.gradient(d_hat, x_hat)
# 计算梯度的L2范数，即对每个样本的梯度向量进行平方和，然后开方，得到每个样本的梯度范数。
# 在你的代码中，gradients 张量的形状是 [100, 4]，但你尝试在 axis=[1, 2]
# 上进行 tf.reduce_sum 操作。由于张量只有两个维度，所以没有第三个维度可以进行求和。
# ddx = tf.sqrt(tf.reduce_sum(gradients ** 2, axis=[1, 2]))
ddx = tf.sqrt(tf.reduce_sum(gradients ** 2, axis=[1]))
# 算梯度惩罚项，它是梯度范数与1的差的平方的平均值。在WGAN中，我们希望梯度范数接近1，
# 因此这个惩罚项会惩罚那些使梯度范数远离1的判别器。
d_regularizer = tf.reduce_mean((ddx - 1.0) ** 2)
# print("gradient_penalty")
return d_regularizer