TensorFlow训练时如何打印各层张量值及epoch后隐藏层值？

Hey there! Since you're just starting out with TensorFlow, let's keep this solution simple and aligned with the beginner tutorial you're following. Here are two straightforward approaches to get the tensor values you need:

方法1：在模型层中插入实时打印操作 #

If you want to see tensor values/shapes as the model trains step-by-step, you can use tf.keras.layers.Lambda to add a quick print layer right after your hidden layers. This lets you peek at outputs during training without messing up your core model structure.

Example code (adapted to the typical beginner tutorial network):

import tensorflow as tf
import sys

# Your original model (from the beginner tutorial)
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)),
    # Insert a Lambda layer to print hidden layer outputs
    tf.keras.layers.Lambda(lambda x: tf.print(
        "Hidden layer output shape:", tf.shape(x),
        "\nSample output values:", x[:3],  # Print first 3 samples
        summarize=5,  # Limit displayed elements to avoid clutter
        output_stream=sys.stdout
    )),
    tf.keras.layers.Dense(10, activation='softmax')
])

Adjust summarize or the slice x[:3] based on how much detail you want—this keeps your training logs from getting flooded.

方法2：自定义回调函数（epoch结束后获取隐藏层输出） #

For capturing hidden layer outputs after every epoch (which is great for tracking how the layer learns over time), a custom Keras callback is the cleanest way. Here's how to set it up:

import numpy as np

class HiddenLayerLogger(tf.keras.callbacks.Callback):
    def __init__(self, data_to_use):
        super().__init__()
        self.data = data_to_use  # Use training or validation data
        # Grab the hidden layer you want to monitor (e.g., first Dense layer)
        self.target_layer = model.get_layer(index=0)
        # Build a tiny helper model to output only the hidden layer's results
        self.hidden_output_model = tf.keras.Model(
            inputs=model.input, 
            outputs=self.target_layer.output
        )

    def on_epoch_end(self, epoch, logs=None):
        # Calculate hidden layer outputs for your dataset
        hidden_output = self.hidden_output_model.predict(self.data[0], verbose=0)
        # Print results with clear epoch labeling
        print(f"\n=== Epoch {epoch+1} Hidden Layer Output ===")
        print(f"Output shape: {hidden_output.shape}")
        print(f"First 2 samples' outputs:\n{hidden_output[:2]}")

# Assume you have validation data (x_val, y_val) from the tutorial
logger = HiddenLayerLogger(data_to_use=(x_val, y_val))

# Add the callback when training your model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(
    x_train, y_train,
    epochs=5,
    validation_data=(x_val, y_val),
    callbacks=[logger]
)

This callback automatically runs after each epoch, so you don't have to manually extract outputs during training.

Quick Tips for Beginners #

• If you built your model with the Functional API, you can reference layers by name (e.g., model.get_layer(name="my_hidden_layer")) instead of index.
• If printing to the console gets messy, redirect output to a file: replace sys.stdout in tf.print with open('layer_logs.txt', 'a'), or add file writing logic in the callback.

内容的提问来源于stack exchange，提问作者Alan Wang