PyTorch 2.0 故障排除（舊）

作者: Michael Lazos

注意

本文件已過時，現主要作為如何執行 torch.compile 精簡工具的主要資源。請參閱 更新的故障排除文件。另有一份更 全面的 torch.compile 手冊 可用。

我們正在積極開發除錯工具、效能分析工具，並改進錯誤和警告訊息。下表列出了可用工具及其典型用法。如需更多幫助，請參閱 診斷執行時錯誤。

標題

工具	目的	用法
資訊日誌	檢視編譯摘要步驟	torch._logging.set_logs(dynamo = logging.INFO) 或 TORCH_LOGS="dynamo"
除錯日誌	檢視編譯詳細步驟（列印每個被追蹤的指令）	torch._logging.set_logs(dynamo = logging.DEBUG) 和 torch._dynamo.config.verbose = True，或 TORCH_LOGS="+dynamo" TORCHDYNAMO_VERBOSE=1
任意後端精簡工具	查詢可復現任意後端錯誤的最小子圖	設定環境變數 TORCHDYNAMO_REPRO_AFTER="dynamo"
TorchInductor 精簡工具	如果已知錯誤發生在 AOTAutograd 之後，則查詢可在 TorchInductor 降低過程中復現錯誤的最小子圖	設定環境變數 TORCHDYNAMO_REPRO_AFTER="aot"
Dynamo 精度精簡工具	當您懷疑問題出在 AOTAutograd 時，查詢可在 eager 模式模型和最佳化模型之間復現精度問題的最小子圖	TORCHDYNAMO_REPRO_AFTER="dynamo" TORCHDYNAMO_REPRO_LEVEL=4
Inductor 精度精簡工具	當您懷疑問題出在後端（例如 inductor）時，查詢可在 eager 模式模型和最佳化模型之間復現精度問題的最小子圖。如果此方法無效，請嘗試 Dynamo 精度精簡工具。	TORCHDYNAMO_REPRO_AFTER="aot" TORCHDYNAMO_REPRO_LEVEL=4
torch._dynamo.explain	查詢圖斷點並顯示其原因	torch._dynamo.explain(fn)(*inputs)
記錄/回放	記錄並回放可在圖捕獲期間復現錯誤的幀	torch._dynamo.config.replay_record_enabled = True
TorchDynamo 函式名過濾	僅編譯具有給定名稱的函式，以減少除錯問題時的干擾	設定環境變數 TORCHDYNAMO_DEBUG_FUNCTION=<name>
TorchInductor 除錯日誌	列印通用 TorchInductor 除錯資訊和生成的 Triton/C++ 程式碼	torch._inductor.config.debug = True
TorchInductor 追蹤	顯示每個 TorchInductor 階段花費的時間 + 輸出程式碼和圖視覺化	設定環境變數 TORCH_COMPILE_DEBUG=1 或 torch._inductor.config.trace.enabled = True

除了資訊日誌和除錯日誌外，您還可以使用 torch._logging 進行更精細的日誌記錄。

診斷執行時錯誤

從高層次看，TorchDynamo 棧包含從 Python 程式碼進行的圖捕獲（TorchDynamo）和一個後端編譯器。例如，後端編譯器可能包含反向圖追蹤（AOTAutograd）和圖降低（TorchInductor）*。錯誤可能發生在棧的任何元件中，並會提供完整的棧追蹤資訊。

要確定錯誤發生在哪一個元件中，您可以使用資訊級別日誌 torch._logging.set_logs(dynamo = logging.INFO) 或 TORCH_LOGS="dynamo"，並查詢 Step #: ... 輸出。日誌在每個步驟開始和結束時記錄，因此錯誤應對應的步驟是最近記錄的、其結束尚未被記錄的步驟。這些步驟對應於棧的以下部分

步驟	元件
1	TorchDynamo
2	編譯器後端
3	TorchInductor

如果資訊日誌不足，您可以使用可用的後端選項。這些選項包括

• "eager": 僅執行 TorchDynamo 前向圖捕獲，然後使用 PyTorch 執行捕獲的圖。這表明錯誤是否由 TorchDynamo 引起。

• "aot_eager": 執行 TorchDynamo 捕獲前向圖，然後執行 AOTAutograd 追蹤反向圖，無需任何額外的後端編譯器步驟。接著將使用 PyTorch eager 執行前向圖和反向圖。這對於將問題範圍縮小到 AOTAutograd 非常有用。

縮小問題的通用步驟如下

1. 使用 "eager" 後端執行您的程式。如果錯誤不再發生，則問題出在使用中的後端編譯器（如果使用 TorchInductor，請繼續執行步驟 2。否則，請參閱 本節）。如果錯誤在使用 "eager" 後端時仍然發生，則這是 在執行 torchdynamo 時發生的錯誤。

2. 僅當使用 TorchInductor 作為後端編譯器時，才需要此步驟。使用 "aot_eager" 後端執行模型。如果此後端引發錯誤，則表明錯誤發生在 AOTAutograd 追蹤期間。如果使用此後端不再發生錯誤，則 錯誤在 TorchInductor 中*。

以下各節將分析這些情況。

注意

TorchInductor 後端包含 AOTAutograd 追蹤和 TorchInductor 編譯器本身。我們將透過將 TorchInductor 稱為後端，並將 TorchInductor 降低稱為降低由 AOTAutograd 追蹤的圖的階段來進行區分。

TorchDynamo 錯誤

如果在 "eager" 後端中發生生成的錯誤，那麼 TorchDynamo 很可能是錯誤的來源。這是一個將生成錯誤的示例程式碼。

import torch

import torch._dynamo as dynamo


def test_assertion_error():
    y = torch.ones(200, 200)
    z = {y: 5}
    return z

compiled_test_assertion_error = torch.compile(test_assertion_error, backend="eager")

compiled_test_assertion_error()

上面的程式碼生成以下錯誤

torch._dynamo.convert_frame: [ERROR] WON'T CONVERT test_assertion_error /scratch/mlazos/torchdynamo/../test/errors.py line 26
due to:
Traceback (most recent call last):
  File "/scratch/mlazos/torchdynamo/torchdynamo/symbolic_convert.py", line 837, in BUILD_MAP
    assert isinstance(k, ConstantVariable) or (
AssertionError

from user code:
   File "/scratch/mlazos/torchdynamo/../test/errors.py", line 34, in test_assertion_error
    z = {y: 5}

Set torch._dynamo.config.verbose=True for more information
==========

如訊息所示，您可以設定 torch._dynamo.config.verbose=True 來獲取 TorchDynamo 錯誤和使用者程式碼的完整棧追蹤。除了此標誌外，您還可以透過 torch._logging.set_logs(dynamo = logging.INFO) 或 TORCH_LOGS="dynamo" 設定 TorchDynamo 的 log_level。這些級別包括

• logging.DEBUG 或 TORCH_LOGS="+dynamo": 列印遇到的所有指令，以及下面列出的所有日誌級別。

• logging.INFO: 列印每個被編譯的函式（原始和修改後的位元組碼）和捕獲的圖，以及下面列出的所有日誌級別。

• logging.WARNING（預設）: 列印圖斷點，以及下面列出的所有日誌級別。

• logging.ERROR: 僅列印錯誤。

如果模型非常大，日誌可能會變得非常多。如果錯誤發生在模型 Python 程式碼的深層，僅執行發生錯誤的幀可以有助於更輕鬆地進行除錯。有兩種可用工具可以實現這一點

• 將環境變數 TORCHDYNAMO_DEBUG_FUNCTION 設定為所需函式名稱，將僅對該名稱的函式執行 torchdynamo。

• 啟用記錄/回放工具（設定 torch._dynamo.config.replay_record_enabled = True），該工具在遇到錯誤時會轉儲執行記錄。然後可以回放此記錄，以僅執行發生錯誤的幀。

診斷 TorchInductor 錯誤

如果錯誤未在使用 "eager" 後端時發生，則錯誤源是後端編譯器（示例錯誤）。TorchDynamo 有 不同的後端編譯器選擇，TorchInductor 符合大多數使用者的需求。本節以 TorchInductor 為主要示例，但某些工具也可用於其他後端編譯器。

下面是我們關注的棧的部分

選擇 TorchInductor 作為後端後，使用 AOTAutograd 從 torchdynamo 捕獲的前向圖生成反向圖。需要注意的是，錯誤可能在此追蹤過程中發生，也可能在 TorchInductor 將前向圖和反向圖降低到 GPU 程式碼或 C++ 時發生。一個模型通常包含數百或數千個 FX 節點，因此縮小問題發生的具體節點範圍可能非常困難。幸運的是，有一些可用工具可以自動將這些輸入圖精簡到導致問題的節點。第一步是確定錯誤是發生在 AOTAutograd 追蹤反向圖期間，還是在 TorchInductor 降低期間。如上文步驟 2 中所述，可以使用 "aot_eager" 後端僅獨立執行 AOTAutograd，而不進行降低。如果使用此後端仍然發生錯誤，則表明錯誤發生在 AOTAutograd 追蹤期間。

以下是一個示例

import torch

import torch._dynamo as dynamo

model = torch.nn.Sequential(*[torch.nn.Linear(200, 200) for _ in range(5)])

def test_backend_error():

    y = torch.ones(200, 200)
    x = torch.ones(200, 200)
    z = x + y
    a = torch.ops.aten._foobar(z)  # dummy function which errors
    return model(a)


compiled_test_backend_error = torch.compile(test_backend_error, backend="inductor")
compiled_test_backend_error()

執行此程式碼應該會給出此錯誤，下方附有更長的棧追蹤資訊

Traceback (most recent call last):
  File "/scratch/mlazos/torchdynamo/torchinductor/graph.py", line 246, in call_function
    return lowerings[target](*args, **kwargs)
  File "/scratch/mlazos/torchdynamo/torchinductor/lowering.py", line 185, in wrapped
    return decomp_fn(*args, **kwargs)
  File "/scratch/mlazos/torchdynamo/torchinductor/lowering.py", line 810, in _foobar
    assert False
AssertionError
...

帶完整棧追蹤的錯誤

如果您將 torch.compile(backend="inductor") 更改為 torch.compile(backend="aot_eager")，它將無錯誤執行，因為 問題 出在 TorchInductor 降低過程中，而不是在 AOTAutograd 中。

精簡 TorchInductor 錯誤

接下來，我們執行精簡工具以獲取最小的可復現示例。設定環境變數 TORCHDYNAMO_REPRO_AFTER="aot"（或直接設定 torch._dynamo.config.repro_after="aot"）將生成一個 Python 程式，該程式會將 AOTAutograd 生成的圖縮減到可復現錯誤的最小子圖。（請參閱下方關於精簡 TorchDynamo 生成的圖的示例）使用此環境變數執行程式應顯示幾乎 相同的輸出，並附加一行指示 minifier_launcher.py 已寫入到何處。輸出目錄可透過將 torch._dynamo.config.base_dir 設定為有效的目錄名進行配置。最後一步是執行精簡工具並檢查它是否成功執行。成功執行看起來像 這樣。如果精簡工具成功執行，它將生成可執行的 Python 程式碼，該程式碼可精確復現錯誤。對於我們的示例，程式碼如下

import torch
from torch import tensor, device
import torch.fx as fx
from torch._dynamo.testing import rand_strided
from math import inf
from torch.fx.experimental.proxy_tensor import make_fx

# torch version: 1.13.0a0+gitfddfc44
# torch cuda version: 11.6
# torch git version: fddfc4488afb207971c54ad4bf58130fdc8a4dc5


# CUDA Info:
# nvcc: NVIDIA (R) Cuda compiler driver
# Copyright (c) 2005-2022 NVIDIA Corporation
# Built on Thu_Feb_10_18:23:41_PST_2022
# Cuda compilation tools, release 11.6, V11.6.112
# Build cuda_11.6.r11.6/compiler.30978841_0

# GPU Hardware Info:
# NVIDIA A100-SXM4-40GB : 8

from torch.nn import *

class Repro(torch.nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, add):
        _foobar = torch.ops.aten._foobar.default(add);  add = None
        return (_foobar,)

args = [((200, 200), (200, 1), torch.float32, 'cpu')]
args = [rand_strided(shape, stride, dtype, device) for shape, stride, dtype, device in args]
mod = make_fx(Repro())(*args)
from torch._inductor.compile_fx import compile_fx_inner

compiled = compile_fx_inner(mod, args)
compiled(*args)

Repro 模組的 forward 方法包含導致問題的確切運算元。提交問題時，請包含任何精簡後的可復現示例，以便於除錯。

精簡後端編譯器錯誤

對於 TorchInductor 之外的後端編譯器，查詢導致錯誤的子圖的過程與 TorchInductor 錯誤中的過程幾乎相同，但有一個重要區別。即精簡工具現在將執行在由 TorchDynamo 追蹤的圖上，而不是 AOTAutograd 的輸出圖上。讓我們來看一個示例。

import torch

import torch._dynamo as dynamo

model = torch.nn.Sequential(*[torch.nn.Linear(200, 200) for _ in range(5)])
# toy compiler which fails if graph contains relu
def toy_compiler(gm: torch.fx.GraphModule, _):
    for node in gm.graph.nodes:
        if node.target == torch.relu:
            assert False

    return gm


def test_backend_error():
    y = torch.ones(200, 200)
    x = torch.ones(200, 200)
    z = x + y
    a = torch.relu(z)
    return model(a)


compiled_test_backend_error = torch.compile(test_backend_error, backend=toy_compiler)
compiled_test_backend_error()

為了在 TorchDynamo 追蹤前向圖後執行程式碼，您可以使用 TORCHDYNAMO_REPRO_AFTER 環境變數。使用 TORCHDYNAMO_REPRO_AFTER="dynamo"（或 torch._dynamo.config.repro_after="dynamo"）執行此程式應產生此 輸出 和 {torch._dynamo.config.base_dir}/repro.py 中的以下程式碼。

注意

TORCHDYNAMO_REPRO_AFTER 的另一個選項是 "aot"，它將在生成反向圖後執行精簡工具。

import torch
import torch._dynamo as dynamo
from torch import tensor, device
import torch.fx as fx
from torch._dynamo.testing import rand_strided
from math import inf
from torch._dynamo.debug_utils import run_fwd_maybe_bwd

from torch.nn import *

class Repro(torch.nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, add):
        relu = torch.relu(add);  add = None
        return (relu,)


mod = Repro().cuda()
opt_mod = torch.compile(mod, backend="None")


args = [((200, 200), (200, 1), torch.float32, 'cpu', False)]
args = [rand_strided(sh, st, dt, dev).requires_grad_(rg) for (sh, st, dt, dev, rg) in args]


with torch.cuda.amp.autocast(enabled=False):
    ref = run_fwd_maybe_bwd(mod, args)
    res = run_fwd_maybe_bwd(opt_mod, args)

精簡工具成功將圖縮減到在 toy_compiler 中引發錯誤的運算元。與 TorchInductor 錯誤中的過程的另一個不同之處在於，精簡工具在遇到後端編譯器錯誤後會自動執行。成功執行後，精簡工具會將 repro.py 寫入到 torch._dynamo.config.base_dir。

效能分析

訪問 TorchDynamo 效能分析器

TorchDynamo 有一個內建的統計函式，用於收集和顯示在每個編譯階段花費的時間。在執行 Torch._Dynamo 後，透過呼叫 torch._dynamo.utils.compile_times() 可以訪問這些統計資訊。預設情況下，它會返回一個字串表示，顯示每個 TorchDynamo 函式按名稱統計的編譯時間。

使用 TORCH_COMPILE_DEBUG 除錯 TorchInductor

TorchInductor 有一個內建的統計和追蹤功能，用於顯示每個編譯階段花費的時間、輸出程式碼、輸出圖視覺化和 IR 轉儲。這是一個除錯工具，旨在更容易理解和排除 TorchInductor 的內部問題。

我們使用以下測試程式（repro.py）執行一個示例

import torch

@torch.compile()
def test_model(x):
    model = torch.nn.Sequential(
        torch.nn.Linear(10, 10),
        torch.nn.LayerNorm(10),
        torch.nn.ReLU(),
    )
    return model(x)


y = test_model(torch.ones(10, 10))

設定環境變數 TORCH_COMPILE_DEBUG=1 將建立一個除錯追蹤目錄，預設情況下該目錄位於當前目錄並命名為 torch_compile_debug（這可以在 torchdynamo 配置欄位 debug_dir_root 和 env var TORCH_COMPILE_DEBUG_DIR 中覆蓋）。在此目錄內，每次執行都將有一個單獨的資料夾，以執行的時間戳和程序 ID 命名

$ env TORCH_COMPILE_DEBUG=1 python repro.py
$ cd torch_compile_debug
$ ls
run_2023_03_01_08_20_52_143510-pid_180167

在執行資料夾中，將有一個包含除錯日誌的 torchdynamo 目錄，以及一個 torchinductor 資料夾，該資料夾包含每個已編譯核心的子資料夾，其中包含 inductor 除錯 artifact。

$ cd
run_2023_03_01_08_20_52_143510-pid_180167
$ ls
torchinductor  torchdynamo

進一步進入 torchinductor 目錄，\*.log 檔案是編譯的 AOT Autograd 階段的日誌，model__0_forward_1.0 包含 inductor 除錯 artifact。

$ cd torchinductor
$ ls
aot_model___0_debug.log  model__0_forward_1.0
$ cd model__0_forward_1.0
$ ls
debug.log  fx_graph_readable.py  fx_graph_runnable.py  fx_graph_transformed.py  ir_post_fusion.txt  ir_pre_fusion.txt  output_code.py

以下是內容的摘要

• fx_graph_readable.py 和 fx_graph_runnable.py 是 inductor 接收到的 fx_graph 的可讀和可執行版本。

• fx_graph_transformed.py 是 inductor 執行所有 fx pass 後的 fx 圖。

• ir\*.txt 是融合前後的 inductor IR。

• output_code.py 是子圖的編譯後 triton 核心。

以下是測試程式的 示例除錯目錄內容

import torch

@torch.compile()
def test_model(x):
    model = torch.nn.Sequential(
        torch.nn.Linear(10, 10),
        torch.nn.LayerNorm(10),
        torch.nn.ReLU(),
    )
    return model(x)


y = test_model(torch.ones(10, 10))

該除錯追蹤中的每個檔案都可以透過 torch._inductor.config.trace.* 進行啟用和停用。效能分析和圖表預設情況下都是停用的，因為生成它們開銷很大。

此新除錯格式中的單個節點如下所示

buf1: SchedulerNode(ComputedBuffer)
buf1.writes =
    {   MemoryDep(name='buf1', index=0, size=()),
        MemoryDep(name='buf1', index=0, size=(s0,))}
buf1.unmet_dependencies = {MemoryDep(name='buf0', index=c0, size=(s0,))}
buf1.met_dependencies = {MemoryDep(name='primals_2', index=c0, size=(s0,))}
buf1.group.device = cuda:0
buf1.group.iteration = (1, s0)
buf1.sizes = ([], [s0])
class buf1_loop_body:
    var_ranges = {z0: s0}
    index0 = z0
    index1 = 0
    def body(self, ops):
        get_index = self.get_index('index0')
        load = ops.load('buf0', get_index, False)
        get_index_1 = self.get_index('index0')
        load_1 = ops.load('primals_2', get_index_1, False)
        add = ops.add(load, load_1)
        get_index_2 = self.get_index('index1')
        reduction = ops.reduction('buf1', torch.float32, torch.float32, 'sum', get_index_2, add)
        return reduction

請參閱 示例除錯目錄輸出 以獲取更多示例。

圖斷點

給定像這樣的程式

def some_fun(x):
    ...

compiled_fun = torch.compile(some_fun, ...)
...

TorchDynamo 會嘗試將 some_fun 內的所有 torch/tensor 運算元編譯成一個單獨的 FX 圖，但可能無法將所有內容捕獲到同一個圖內。

某些圖斷點的原因對於 TorchDynamo 來說是不可克服的，並且無法輕鬆修復。—— 呼叫 torch 以外的 C 擴充套件對 torchdynamo 是不可見的，並且可以在 TorchDynamo 無法引入必要的 guard（參見 使 Dynamo 健全：Guard）的情況下執行任意操作，以確保編譯後的程式可以安全地重用。如果生成的片段很小，圖斷點會阻礙效能。為了最大化效能，儘量減少圖斷點非常重要。

識別圖斷點的原因

要識別程式中的所有圖斷點及其相關原因，可以使用 torch._dynamo.explain。此工具對提供的函式執行 TorchDynamo，並聚合遇到的圖斷點。以下是一個示例用法

import torch
import torch._dynamo as dynamo
def toy_example(a, b):
    x = a / (torch.abs(a) + 1)
    print("woo")
    if b.sum() < 0:
        b = b * -1
    return x * b
explanation = dynamo.explain(toy_example)(torch.randn(10), torch.randn(10))
print(explanation_verbose)
"""
Graph Count: 3
Graph Break Count: 2
Op Count: 5
Break Reasons:
  Break Reason 1:
    Reason: builtin: print [<class 'torch._dynamo.variables.constant.ConstantVariable'>] False
    User Stack:
      <FrameSummary file foo.py, line 5 in toy_example>
  Break Reason 2:
    Reason: generic_jump TensorVariable()
    User Stack:
      <FrameSummary file foo.py, line 6 in torch_dynamo_resume_in_toy_example_at_5>
Ops per Graph:
  ...
Out Guards:
  ...
"""

輸出包括

• out_guards - 一個列表的列表，其中每個子列表包含必須透過的 guard，以確保追蹤的圖有效。

• graphs - 一個成功追蹤的圖模組列表。

• ops_per_graph - 一個列表的列表，其中每個子列表包含在圖表中執行的運算元。

要在遇到的第一個圖斷點處引發錯誤，請使用 fullgraph 模式。此模式停用 TorchDynamo 的 Python 回退，僅當整個程式可轉換為單個圖時才會成功。示例用法

def toy_example(a, b):
   ...

compiled_toy = torch.compile(toy_example, fullgraph=True, backend=<compiler>)(a, b)

過度重新編譯

當 TorchDynamo 編譯一個函式（或其一部分）時，它會做出關於區域性變數和全域性變數的某些假設，以便進行編譯器最佳化，並將這些假設表示為在執行時檢查特定值的 guard。如果這些 guard 中有任何一個失敗，Dynamo 將重新編譯該函式（或其一部分），最多 torch._dynamo.config.recompile_limit 次。如果您的程式達到了快取限制，您首先需要確定哪個 guard 失敗以及程式的哪一部分觸發了它。

如果您的程式表現出有限的動態性，您可以透過調整 TorchDynamo 快取限制來允許編譯和快取每個變體，但如果快取限制設定得太高，您可能會發現重新編譯的開銷超過了任何最佳化收益。

torch._dynamo.config.recompile_limit = <your desired cache limit>

TorchDynamo 計劃支援許多常見的動態張量形狀場景，例如變化的批大小或序列長度。它不計劃支援 rank-dynamism。在此期間，可以透過設定特定的快取限制並結合 bucketing 技術，為某些動態模型實現可接受的重新編譯次數。

精度除錯

如果您設定環境變數 TORCHDYNAMO_REPRO_LEVEL=4，也可以精簡精度問題，它類似於 git bisect 模型，完整的可復現示例可能像 TORCHDYNAMO_REPRO_AFTER="aot" TORCHDYNAMO_REPRO_LEVEL=4。我們需要這樣做是因為下游編譯器會生成程式碼，無論是 Triton 程式碼還是 C++ 後端，這些下游編譯器產生的數值可能會有細微差異，但卻對您的訓練穩定性產生巨大影響。因此，精度偵錯程式對於我們檢測程式碼生成或後端編譯器中的錯誤非常有用。

如果您想確保 torch 和 triton 之間的隨機數生成是一致的，則可以啟用 torch._inductor.config.fallback_random = True

擴充套件除錯

可以透過使用以下實驗性標誌啟用擴充套件除錯。

TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED - 如果 guard 的字串表示與此標誌值匹配，則提供擴充套件除錯資訊。例如，將其設定為“Ne(s0, 10)”以在 guard 發出時生成完整的 Python 和 C++ 回溯。TORCHDYNAMO_EXTENDED_DEBUG_CREATE_SYMBOL - 在分配特定符號時提供擴充套件除錯資訊。例如，將其設定為“u2”以在此符號建立時生成完整的 Python 和 C++ 回溯。TORCHDYNAMO_EXTENDED_DEBUG_CPP - 為所有擴充套件除錯設定以及錯誤提供擴充套件除錯資訊（C++ 回溯）。例如，將其設定為“1”。C++ 回溯很慢且資訊非常冗餘，因此預設情況下不包含在擴充套件除錯中。

冷啟動計時和快取損壞除錯

為了測量冷啟動編譯時間或除錯快取損壞，可以傳入 TORCHINDUCTOR_FORCE_DISABLE_CACHES=1 或設定 torch._inductor.config.force_disable_caches = True，這將覆蓋任何其他快取配置選項並停用所有編譯時快取。