我在Tensorflow上观看了关于Eager Execution的Tensorflow开发者峰会视频,并且演示者介绍了"渐变磁带".现在我了解Gradient Tape跟踪TF模型中发生的自动差异.

我试图理解为什么我会使用Gradient Tape？任何人都可以解释Gradient Tape如何用作诊断工具吗？为什么有人会使用Gradient Tape而不仅仅是权重的Tensorboard可视化.

因此,我认为模型发生的自动区分是计算每个节点的梯度 - 这意味着在给定一批数据的情况下,调整每个节点的权重和偏差.这就是学习过程.但我的印象是,我实际上可以使用一个tf.keras.callback.TensorBoard()调用来查看训练的张量板可视化 - 所以我可以观察每个节点上的权重并确定是否有任何死或过饱和的节点.

仅使用渐变色带来查看某些渐变是否变为零或变得非常大等等？或者是否有其他一些使用渐变色带？

我正在尝试使用Tensorflow的新的急切执行模式来遵循http://www.hackevolve.com/where-cnn-is-looking-grad-cam/上的指南。特别是有一句话让我感到难过：

grads = K.gradients(class_output, last_conv_layer.output)[0]

我了解它正在查找最后一个卷积层与特定类的输出之间的梯度。但是，我无法弄清楚如何使用来完成此操作GradientTape，因为（a）都是张量而不是变量，并且（b）一个不是直接从另一个张量派生的（它们的特征图已经存在，因此没有图，它们实际上是独立的） ）。

编辑：更多信息。尚未有任何参与者回答，因此，我将继续添加自发布问题以来我已尝试的内容：

显而易见的步骤是通过Eager执行来重现第一部分。

import numpy as np
import cv2
import tensorflow as tf
tf.enable_eager_execution()

model = tf.keras.models.load_model("model.h5")
print(type(model))
# tensorflow.python.keras.engine.sequential.Sequential

from dataset import prepare_dataset
_, ds, _, _, _, _ = prepare_dataset() # ds is a tf.data.Dataset
print(type(ds))
# tensorflow.python.data.ops.dataset_ops.DatasetV1Adapter

it = train_ds.make_one_shot_iterator()
img, label = it.get_next()
print(type(img), img.shape)
# <class 'tensorflow.python.framework.ops.EagerTensor'> (192, 192, 3)

print(type(label), label.shape)
# <class 'tensorflow.python.framework.ops.EagerTensor'> (2,)

img = np.expand_dims(img, axis=0)
print(img.shape)
# (1, 192, 192, …

所以这个问题可能源于缺乏对张量流的了解。但是我正在尝试使用 构建一个多层感知器tensorflow 2.0，但没有Keras.

原因是我的机器学习课程要求我们不使用 keras。你为什么会问？我不确定。

我已经tensorflow 2.0用 Keras 轻松实现了我们的模型，现在我想在没有keras.

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=784))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(5, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
              optimizer=Adam(),
              metrics=['accuracy'])

X_train = X[:7000]
y_train = tf.keras.utils.to_categorical(y[:7000], num_classes=5)
X_dev = X[7000:]
y_dev = tf.keras.utils.to_categorical(y[7000:], num_classes=5)

model.fit(X_train, y_train,
          epochs=100,
          batch_size=128)
score = model.evaluate(X_dev, y_dev, batch_size=128)
print(score)

这是我的问题。每当我在 上查找文档时Tensorflow 2.0，甚至自定义培训的指南都在使用 Keras。

由于占位符和会话在tensorflow 2.0.

我可以制作张量对象。我的印象是我需要使用 Eager Execution 并使用渐变磁带。但是我仍然不确定如何将这些东西放在一起。

现在我的问题是。我应该在哪里寻找更好的理解？哪个方向下降最大？

请告诉我我是否做错了这个堆栈溢出帖子。这是我第一次来这里。

我遇到了tensorflow 2.0的一段代码，用于计算损失。总损失由两部分组成：1）正则化损失，2）预测损失。我的问题是为什么model.losses正则化损失？model这是 的一个实例tf.keras.Model。我对 tensorflow 官方 API 文档有点困惑。tf.keras.Model，它说

与此层相关的损失。

访问此属性时会创建变量正则化张量，因此它非常安全：访问 a 下的损失tf.GradientTape会将梯度传播回相应的变量。

为什么我们可以通过访问losses财产获得正则化损失？另外，什么是eager safe？如果losses属性返回正则化损失，为什么它被命名losses而不是regularization_loss？

with tf.GradientTape() as tape:
  outputs = model(images, training=True)
  regularization_loss = tf.reduce_sum(model.losses)
  pred_loss = ...
  total_loss = pred_loss + regularization_loss

有人可以解释一下tensorflow的eager-mode工作原理。我正在尝试建立一个简单的回归，如下所示：

编辑：我正在更新我的问题，这是我的完整代码，现在问题来自梯度计算，它返回零。我检查了非零的损失值。

import tensorflow as tf
tfe = tf.contrib.eager
tf.enable_eager_execution()
import numpy as np
def make_model():
    net = tf.keras.Sequential()
    net.add(tf.keras.layers.Dense(4, activation='relu'))
    net.add(tf.keras.layers.Dense(1))
    return net

def compute_loss(pred, actual):
    return tf.reduce_mean(tf.square(tf.subtract(pred, actual)))

def compute_gradient(model, pred, actual):
    """compute gradients with given noise and input"""
    with tf.GradientTape() as tape:
        loss = compute_loss(pred, actual)
    grads = tape.gradient(loss, model.variables)
    return grads, loss

def apply_gradients(optimizer, grads, model_vars):
    optimizer.apply_gradients(zip(grads, model_vars))

model = make_model()
optimizer = tf.train.AdamOptimizer(1e-4)

x = np.linspace(0,1,1000)
y = x+np.random.normal(0,0.3,1000)
y = y.astype('float32')
train_dataset …

实际上，我在 TensorFlow 1.13.0 中已经发现了这个问题。（tensorflow1.12.0 运行良好）。

我的代码被列为一个简单的例子：

def Lambda layer(temp):
    print(temp)
    return temp

在我的 Keras 模型中用作 lambda 层。在tensorflow1.12.0中，print(temp)可以输出如下的详细数据

[<tf.Tensor: id=250, shape=(1024, 2, 32), dtype=complex64, numpy=
array([[[ 7.68014073e-01+0.95353246j,  7.01403618e-01+0.64385843j,
          8.30483198e-01+1.0340731j , ..., -8.88018191e-01+0.4751519j ,
         -1.20197642e+00+0.6313924j , -1.03787208e+00+0.22964947j],
        [-7.94382274e-01+0.56390345j, -4.73938555e-01+0.55901265j,
         -8.73749971e-01+0.67095983j, ..., -5.81580341e-01-0.91620034j,
         -7.04443693e-01-1.2709806j , -3.23135853e-01-1.0887597j ]],

这是因为我使用 1024 作为 batch_size。但是当我更新到 tensorflow1.13.0 或 TensorFlow 2.0 时，同样的代码输出

Tensor("lambda_1/truediv:0", shape=(None, 1), dtype=float32)

这太可怕了，因为我不知道确切的错误。那么，关于如何解决它的任何想法？

我在 Eager Execution 中使用 TensorFlow 1.12，我想在训练期间检查不同点的梯度值和权重以进行调试。这个答案使用 TensorBoard 来获得很好的权重和梯度分布图，这正是我想要的。但是，当我使用Keras 的 TensorBoard callback 时，我得到了这个：

WARNING:tensorflow:Weight and gradient histograms not supported for eagerexecution, setting `histogram_freq` to `0`.

换句话说，这与急切执行不兼容。有没有其他方法可以打印渐变和/或权重？大多数非 TensorBoard 答案似乎依赖于基于图的执行。

我在玩 TensorFlow，我正在尝试将 Keras 模型导出为 TensorFlow 模型。我遇到了上述错误。我正在关注 Lynda 的“使用 Keras 2.0 构建深度学习应用程序”（https://www.linkedin.com/learning/building-deep-learning-applications-with-keras-2-0/exporting-google-cloud-兼容模型？u=42751868）

在尝试构建张量流模型时，我遇到了这个错误，在第 66 行抛出，其中定义了添加元图和变量函数。

第 66 行，在 build_tensor_info 中引发 RuntimeError("build_tensor_info is not supported in Eager mode.") RuntimeError: build_tensor_info is not supported in Eager mode。

...model_builder.add_meta_graph_and_variables(
        K.get_session(),
        tags=[tf.compat.v1.saved_model.tag_constants.SERVING],
        signature_def_map={
            tf.compat.v1.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature_def
        }
    )
...

大家有什么想法吗？

我正在尝试在Eager Execution中运行基本的CNN keras模型，但Tensorflow拒绝将模型视为急切的模型。我最初在稳定的1.13分支（最新）中尝试过此操作，请确保启用急切执行而没有结果。我升级到了2.0（最新），但是什么也没有。

模型

class CNN2(tf.keras.Model):

  def __init__(self, num_classes=7):
    super(CNN2, self).__init__()
    self.cnn1 = tf.keras.layers.Conv2D(32, (5,5), padding='same', strides=(2, 2),
                                      kernel_initializer='he_normal')
    self.bn1 = tf.keras.layers.BatchNormalization()
    self.cnn2 = tf.keras.layers.Conv2D(64, (5,5), padding='same', strides=(2, 2),
                                      kernel_initializer='he_normal')
    self.cnn3 = tf.keras.layers.Conv2D(128, (5,5), padding='same', strides=(2, 2),
                                      kernel_initializer='he_normal')
    self.bn2 = tf.keras.layers.BatchNormalization()
    self.pool = tf.keras.layers.MaxPooling2D((2,2))
    self.dnn1 = tf.keras.layers.Dense(128)
    self.dropout1 = tf.keras.layers.Dropout(0.45)
    self.flatten = tf.keras.layers.Flatten()
    self.dnn2 = tf.keras.layers.Dense(512)
    self.dnn3 = tf.keras.layers.Dense(256)
    self.classifier = tf.keras.layers.Dense(num_classes)    

  def simpleLoop(self, inputs, x):
        #x_Numpy = x.numpy(),
        for i, input in inputs:
            print("{0} - {1}".format(i,len(input)))             

  def call(self, inputs, …

我正在尝试在tf.Keras（TensorFlow 2.0.0rc0）中为稀疏注释数据的3-D U-Net 实现依赖于样本和像素的依赖损失加权（Cicek 2016，arxiv：1606.06650）。

这是我的代码：

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, losses, models

# disabling eager execution makes this example work:
# tf.python.framework_ops.disable_eager_execution()


def get_loss_fcn(w):
    def loss_fcn(y_true, y_pred):
        loss = w * losses.mse(y_true, y_pred)
        return loss
    return loss_fcn


data_x = np.random.rand(5, 4, 1)
data_w = np.random.rand(5, 4)
data_y = np.random.rand(5, 4, 1)

x = layers.Input([4, 1])
w = layers.Input([4])
y = layers.Activation('tanh')(x)
model = models.Model(inputs=[x, w], outputs=y)
loss = get_loss_fcn(model.input[1])

# …