已知损失函数梯度dE/dy但无闭合形式损失函数，能否使用Keras（基于TensorFlow）训练模型？

Absolutely yes! You don't need an explicit closed-form loss function to train your model—what matters for gradient-based optimization is the gradient of the loss with respect to your model's parameters (dE/dθ). Since you already have dE/dy (the gradient of loss with respect to model outputs y), you can leverage TensorFlow's automatic differentiation tools to compute dE/dθ via the chain rule, no closed-form E required.

Here's how to implement this in practice, with two common approaches:

1. Custom Training Loop (Most Flexible) #

This is the straightforward method, as it lets you directly control the gradient computation and parameter update steps.

Key Idea #

TensorFlow's GradientTape can compute gradients of a tensor (your model's output y) with respect to model parameters. Crucially, it accepts an output_gradients argument—this is exactly where you pass your precomputed dE/dy, and TensorFlow will handle the chain rule to calculate dE/dθ = dE/dy * dy/dθ.

Example Code #

import tensorflow as tf
from tensorflow.keras import layers, models

# Build your model (replace with your actual architecture)
model = models.Sequential([
    layers.Dense(32, activation='relu', input_shape=(10,)),
    layers.Dense(1)
])

# Choose your optimizer
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)

# --------------------------
# Replace this with YOUR dE/dy calculation logic
# --------------------------
def compute_de_dy(y_true, y_pred):
    # Example: Simulate a non-integrable gradient (replace with your actual gradient)
    # This could be any custom function of y_pred and y_true
    return tf.sin(y_pred) * tf.exp(-tf.abs(y_pred - y_true))

# Define a training step (decorated with @tf.function for speed)
@tf.function
def train_step(x_batch, y_true_batch):
    with tf.GradientTape() as tape:
        # Forward pass: get model output y_pred
        y_pred_batch = model(x_batch, training=True)
    
    # Compute your known dE/dy
    de_dy = compute_de_dy(y_true_batch, y_pred_batch)
    
    # Calculate gradients of parameters using dE/dy as the output gradient
    param_gradients = tape.gradient(
        y_pred_batch, 
        model.trainable_variables, 
        output_gradients=de_dy
    )
    
    # Update model parameters with the optimizer
    optimizer.apply_gradients(zip(param_gradients, model.trainable_variables))
    
    # Optional: Track a "pseudo-loss" for logging (since we don't have E)
    # Use any metric that makes sense for your gradient (e.g., L2 norm of dE/dy)
    pseudo_loss = tf.reduce_mean(tf.square(de_dy))
    return pseudo_loss

# --------------------------
# Training loop
# --------------------------
# Simulate training data (replace with your actual data)
x_train = tf.random.normal((1000, 10))
y_train = tf.random.normal((1000, 1))

epochs = 15
for epoch in range(epochs):
    total_pseudo_loss = 0.0
    # Iterate over batches (use tf.data.Dataset for real-world data)
    for x, y in zip(x_train, y_train):
        x = tf.expand_dims(x, 0)
        y = tf.expand_dims(y, 0)
        batch_loss = train_step(x, y)
        total_pseudo_loss += batch_loss.numpy()
    
    avg_loss = total_pseudo_loss / len(x_train)
    print(f"Epoch {epoch+1}/{epochs} | Avg Pseudo Loss: {avg_loss:.4f}")

2. Using tf.custom_gradient (For Integration with Keras fit() API) #

If you prefer to use Keras's built-in fit() method instead of a full custom loop, you can wrap your model's output with tf.custom_gradient to override the gradient computation. This way, when Keras tries to compute gradients for training, it will use your dE/dy instead of deriving it from a loss function.

Key Idea #

Define a custom layer or a wrapper function that returns your model's output, and specifies a gradient function that returns your precomputed dE/dy. Note that you'll need to pass y_true into this wrapper, which may require modifying your model's input to include labels.

Quick Example Snippet #

@tf.custom_gradient
def gradient_wrapper(y_pred, y_true):
    def grad(_):
        # Return your dE/dy here (ignore the incoming gradient _)
        return compute_de_dy(y_true, y_pred), None
    return y_pred, grad

# Modify your model to accept y_true as an input
class CustomModel(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = layers.Dense(32, activation='relu')
        self.dense2 = layers.Dense(1)
    
    def call(self, inputs, training=False):
        x, y_true = inputs
        y_pred = self.dense2(self.dense1(x))
        # Wrap the output to override gradients
        return gradient_wrapper(y_pred, y_true)

# Then use in fit() with a dummy loss (since gradients are overridden)
model = CustomModel()
model.compile(optimizer=optimizer, loss=lambda y_true, y_pred: 0.0)
model.fit([x_train, y_train], y_train, epochs=15)

Why This Works #

Gradient-based optimization only requires the gradient of the loss with respect to model parameters. By providing dE/dy, you're skipping the step of computing dE/dy from a loss function E—TensorFlow handles the rest of the chain rule to propagate that gradient back to your model's weights.

You don't need to worry about integrating dE/dy to get E; the optimization process doesn't care about E itself, only the direction of the gradient to update parameters.

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