torch.autograd.no_grad
function no_grad<T>(fn: () => T): TContext manager that disables gradient computation.
Temporarily disables automatic differentiation to reduce memory usage and speed up computation. Operations inside the context don't track gradients and don't build the autograd graph, making this essential for inference, evaluation, and any computation where gradients are unnecessary. All operations behave as if they have requires_grad=false, regardless of tensor settings. Essential for:
- Inference: prediction on held-out test/validation data (no gradients needed)
- Model evaluation: computing validation loss and metrics during training
- Memory optimization: disabling gradients in specific forward passes
- Speed: eliminating graph-building overhead for known non-training computations
- Model serving: production inference without gradient tracking overhead
- Iterative optimization: non-differentiable operations mixed with differentiable ones
Key Differences from inference_mode(): Unlike inference_mode, no_grad allows the resulting tensors to be used for gradient computation later if they're brought outside the context. inference_mode is stricter and prevents this. Use no_grad when you want to disable gradients temporarily but might use tensors later for training.
Performance Impact: Disabling gradients eliminates graph-building overhead and saves memory used by tracking operations. The speedup is typically 2-5x depending on model complexity.
- Context switching: Saves and restores previous gradient state, supports nesting
- Performance: 2-5x faster than training due to no graph building
- Orthogonal to model.eval(): Disables gradients, not model dropout/batchnorm behavior
- Tensor.requires_grad ignored: All operations act as if requires_grad=false
- Nested contexts: Can nest no_grad and enable_grad arbitrarily deep
- Global state: Changes torch.is_grad_enabled() temporarily
- Exception safety: Automatically restores gradient state even if function throws
- Not for training: Never use inside training loops without enable_grad() for backward pass
- Nested enable_grad: Use torch.enable_grad() to re-enable inside no_grad context
- Model.parameters(): Still accessible and modifiable inside no_grad
- Different from inference_mode: Tensors can be used for gradients after exiting context
Parameters
fn() => T- Function to execute without gradient tracking. Can be sync or async. All operations inside will have gradient tracking disabled.
Returns
T– The result of the function, with same shape/dtype as if gradients were enabledExamples
// Simple inference without gradients
const x = torch.randn(2, 3, { requires_grad: true });
torch.no_grad(() => {
const y = x.mul(2); // No gradient tracking, requires_grad=false
console.log(y.requires_grad); // false
});// Model evaluation during training
const model = new MyNeuralNet();
const optimizer = new torch.optim.Adam(model.parameters(), { lr: 0.001 });
for (let epoch = 0; epoch < num_epochs; epoch++) {
// Training with gradients
for (const [x, y] of train_loader) {
const pred = model.forward(x);
const loss = criterion(pred, y);
optimizer.zero_grad();
loss.backward();
optimizer.step();
}
// Evaluation without gradients (no gradient tracking overhead)
let val_loss = 0;
torch.no_grad(() => {
for (const [x, y] of val_loader) {
const pred = model.forward(x);
val_loss += criterion(pred, y).item(); // No gradients tracked
}
});
console.log(`Validation loss: ${val_loss / val_loader.length}`);
}// Nested: enable gradients inside no_grad
const x = torch.randn(3, { requires_grad: true });
torch.no_grad(() => {
const y1 = x.mul(2); // No gradients
console.log(y1.requires_grad); // false
const y2 = torch.enable_grad(() => {
return x.mul(3); // Gradients re-enabled
});
console.log(y2.requires_grad); // true (can compute y2.backward())
});// Memory-efficient batch processing
const large_batch_size = 10000;
const processed = torch.no_grad(() => {
// Process large batches without keeping gradient history
return process_large_batch(model, data, large_batch_size);
});
// Gradients of processed are not available (as expected)// Async inference (e.g., data loading with preprocessing)
const prediction = await torch.no_grad(async () => {
const data = await load_data_async(); // No gradients during I/O
const preprocessed = preprocess(data); // No gradients during preprocessing
return model.forward(preprocessed); // No gradients during inference
});See Also
- PyTorch torch.no_grad()
- torch.enable_grad - Re-enable gradients inside no_grad
- torch.inference_mode - Stricter version preventing any gradient use later
- torch.set_grad_enabled - Globally set gradient state
- torch.is_grad_enabled - Check if gradients currently enabled