Delete folder training/unsloth_compiled_cache with huggingface_hub

training/unsloth_compiled_cache/AqlmLoraLinear_peft_forward.py

@@ -1,99 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from unsloth_zoo.temporary_patches.common import torch_compile
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from peft.tuners.lora.aqlm import (torch)
-
-
-torch_addmm = torch.addmm
-torch_add   = torch.add
-torch_is_compiling = torch.compiler.is_compiling
-# torch 2.8 / 2.9 inductor miscompiles addmm(alpha = scaling, beta = 1) traced inside a
-# compiled block (e.g. the VLM decoder MLP), forward and backward; fixed in 2.10 (unsloth#3271).
-torch_lora_no_compiled_addmm = tuple(int(v) for v in torch.__version__.split(".")[:2]) < (2, 10)
-# @torch.compile(fullgraph = False, dynamic = True, options = torch_compile_options)
-def lora_forward(result, lora_A, lora_B, dropout, x, scaling):
-    # Use result.dtype (bfloat16 from base layer) since x may have been cast to float32
-    # by _cast_input_dtype when autocast is disabled
-    target_dtype = result.dtype
-    xA = dropout(x).to(target_dtype) @ lora_A.weight.to(target_dtype).t()
-    if torch_lora_no_compiled_addmm and torch_is_compiling():
-        output = result + scaling * (xA @ lora_B.weight.to(target_dtype).t())
-        bias = lora_B.bias
-        if bias is not None:
-            output = output + scaling * bias.to(target_dtype)
-        return output
-    # output = result + scaling * xA @ lora_B.weight.t()
-    shape = result.shape
-    output = torch_addmm(
-        result.view(-1, shape[-1]),
-        xA.view(-1, xA.shape[-1]),
-        lora_B.weight.to(target_dtype).t(),
-        alpha = scaling,
-        beta = 1,
-    ).view(shape)
-
-    bias = lora_B.bias
-    if bias is not None:
-        output = torch_add(
-            output,
-            bias.to(target_dtype),
-            alpha = scaling,
-        )
-    return output
-pass
-
-def unsloth_forward(self, x: torch.Tensor):
-    # note: logic differs from default Linear because merging is not supported
-    result = self.base_layer(x)
-
-    if self.disable_adapters:
-        return result
-
-    for active_adapter in self.active_adapters:
-        if active_adapter not in self.lora_A.keys():
-            continue
-        lora_A = self.lora_A[active_adapter]
-        lora_B = self.lora_B[active_adapter]
-        dropout = self.lora_dropout[active_adapter]
-        scaling = self.scaling[active_adapter]
-
-        requires_conversion = not torch.is_autocast_enabled()
-        if requires_conversion:
-            expected_dtype = result.dtype
-            x = self._cast_input_dtype(x, lora_A.weight.dtype)
-
-        output = lora_B(lora_A(dropout(x)))
-        if requires_conversion:
-            output = output.to(expected_dtype)
-        output = output * scaling
-        result += output
-    return result

training/unsloth_compiled_cache/AwqLoraLinear_peft_forward.py

@@ -1,98 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from unsloth_zoo.temporary_patches.common import torch_compile
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from peft.tuners.lora.awq import (torch)
-
-
-torch_addmm = torch.addmm
-torch_add   = torch.add
-torch_is_compiling = torch.compiler.is_compiling
-# torch 2.8 / 2.9 inductor miscompiles addmm(alpha = scaling, beta = 1) traced inside a
-# compiled block (e.g. the VLM decoder MLP), forward and backward; fixed in 2.10 (unsloth#3271).
-torch_lora_no_compiled_addmm = tuple(int(v) for v in torch.__version__.split(".")[:2]) < (2, 10)
-# @torch.compile(fullgraph = False, dynamic = True, options = torch_compile_options)
-def lora_forward(result, lora_A, lora_B, dropout, x, scaling):
-    # Use result.dtype (bfloat16 from base layer) since x may have been cast to float32
-    # by _cast_input_dtype when autocast is disabled
-    target_dtype = result.dtype
-    xA = dropout(x).to(target_dtype) @ lora_A.weight.to(target_dtype).t()
-    if torch_lora_no_compiled_addmm and torch_is_compiling():
-        output = result + scaling * (xA @ lora_B.weight.to(target_dtype).t())
-        bias = lora_B.bias
-        if bias is not None:
-            output = output + scaling * bias.to(target_dtype)
-        return output
-    # output = result + scaling * xA @ lora_B.weight.t()
-    shape = result.shape
-    output = torch_addmm(
-        result.view(-1, shape[-1]),
-        xA.view(-1, xA.shape[-1]),
-        lora_B.weight.to(target_dtype).t(),
-        alpha = scaling,
-        beta = 1,
-    ).view(shape)
-
-    bias = lora_B.bias
-    if bias is not None:
-        output = torch_add(
-            output,
-            bias.to(target_dtype),
-            alpha = scaling,
-        )
-    return output
-pass
-
-def unsloth_forward(self, x: torch.Tensor):
-    result = self.quant_linear_module(x)
-
-    if self.disable_adapters:
-        return result
-
-    for active_adapter in self.active_adapters:
-        if active_adapter not in self.lora_A.keys():
-            continue
-        lora_A = self.lora_A[active_adapter]
-        lora_B = self.lora_B[active_adapter]
-        dropout = self.lora_dropout[active_adapter]
-        scaling = self.scaling[active_adapter]
-
-        requires_conversion = not torch.is_autocast_enabled()
-        if requires_conversion:
-            expected_dtype = result.dtype
-            x = self._cast_input_dtype(x, lora_A.weight.dtype)
-
-        output = lora_B(lora_A(dropout(x)))
-        if requires_conversion:
-            output = output.to(expected_dtype)
-        output = output * scaling
-        result = result + output
-    return result

training/unsloth_compiled_cache/BatchNorm1d.py

@@ -1,151 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    if self.weight is not None: input = input.to(self.weight.dtype)
-    self._check_input_dim(input)
-
-    # exponential_average_factor is set to self.momentum
-    # (when it is available) only so that it gets updated
-    # in ONNX graph when this node is exported to ONNX.
-    if self.momentum is None:
-        exponential_average_factor = 0.0
-    else:
-        exponential_average_factor = self.momentum
-
-    if self.training and self.track_running_stats:
-        # TODO: if statement only here to tell the jit to skip emitting this when it is None
-        if self.num_batches_tracked is not None:  # type: ignore[has-type]
-            self.num_batches_tracked.add_(1)  # type: ignore[has-type]
-            if self.momentum is None:  # use cumulative moving average
-                exponential_average_factor = 1.0 / float(self.num_batches_tracked)
-            else:  # use exponential moving average
-                exponential_average_factor = self.momentum
-
-    r"""
-    Decide whether the mini-batch stats should be used for normalization rather than the buffers.
-    Mini-batch stats are used in training mode, and in eval mode when buffers are None.
-    """
-    if self.training:
-        bn_training = True
-    else:
-        bn_training = (self.running_mean is None) and (self.running_var is None)
-
-    r"""
-    Buffers are only updated if they are to be tracked and we are in training mode. Thus they only need to be
-    passed when the update should occur (i.e. in training mode when they are tracked), or when buffer stats are
-    used for normalization (i.e. in eval mode when buffers are not None).
-    """
-    return F.batch_norm(
-        input,
-        # If buffers are not to be tracked, ensure that they won't be updated
-        (
-            self.running_mean
-            if not self.training or self.track_running_stats
-            else None
-        ),
-        self.running_var if not self.training or self.track_running_stats else None,
-        self.weight,
-        self.bias,
-        bn_training,
-        exponential_average_factor,
-        self.eps,
-    ).to(original_dtype)

training/unsloth_compiled_cache/BatchNorm2d.py

@@ -1,151 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    if self.weight is not None: input = input.to(self.weight.dtype)
-    self._check_input_dim(input)
-
-    # exponential_average_factor is set to self.momentum
-    # (when it is available) only so that it gets updated
-    # in ONNX graph when this node is exported to ONNX.
-    if self.momentum is None:
-        exponential_average_factor = 0.0
-    else:
-        exponential_average_factor = self.momentum
-
-    if self.training and self.track_running_stats:
-        # TODO: if statement only here to tell the jit to skip emitting this when it is None
-        if self.num_batches_tracked is not None:  # type: ignore[has-type]
-            self.num_batches_tracked.add_(1)  # type: ignore[has-type]
-            if self.momentum is None:  # use cumulative moving average
-                exponential_average_factor = 1.0 / float(self.num_batches_tracked)
-            else:  # use exponential moving average
-                exponential_average_factor = self.momentum
-
-    r"""
-    Decide whether the mini-batch stats should be used for normalization rather than the buffers.
-    Mini-batch stats are used in training mode, and in eval mode when buffers are None.
-    """
-    if self.training:
-        bn_training = True
-    else:
-        bn_training = (self.running_mean is None) and (self.running_var is None)
-
-    r"""
-    Buffers are only updated if they are to be tracked and we are in training mode. Thus they only need to be
-    passed when the update should occur (i.e. in training mode when they are tracked), or when buffer stats are
-    used for normalization (i.e. in eval mode when buffers are not None).
-    """
-    return F.batch_norm(
-        input,
-        # If buffers are not to be tracked, ensure that they won't be updated
-        (
-            self.running_mean
-            if not self.training or self.track_running_stats
-            else None
-        ),
-        self.running_var if not self.training or self.track_running_stats else None,
-        self.weight,
-        self.bias,
-        bn_training,
-        exponential_average_factor,
-        self.eps,
-    ).to(original_dtype)

training/unsloth_compiled_cache/BatchNorm3d.py

@@ -1,151 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    if self.weight is not None: input = input.to(self.weight.dtype)
-    self._check_input_dim(input)
-
-    # exponential_average_factor is set to self.momentum
-    # (when it is available) only so that it gets updated
-    # in ONNX graph when this node is exported to ONNX.
-    if self.momentum is None:
-        exponential_average_factor = 0.0
-    else:
-        exponential_average_factor = self.momentum
-
-    if self.training and self.track_running_stats:
-        # TODO: if statement only here to tell the jit to skip emitting this when it is None
-        if self.num_batches_tracked is not None:  # type: ignore[has-type]
-            self.num_batches_tracked.add_(1)  # type: ignore[has-type]
-            if self.momentum is None:  # use cumulative moving average
-                exponential_average_factor = 1.0 / float(self.num_batches_tracked)
-            else:  # use exponential moving average
-                exponential_average_factor = self.momentum
-
-    r"""
-    Decide whether the mini-batch stats should be used for normalization rather than the buffers.
-    Mini-batch stats are used in training mode, and in eval mode when buffers are None.
-    """
-    if self.training:
-        bn_training = True
-    else:
-        bn_training = (self.running_mean is None) and (self.running_var is None)
-
-    r"""
-    Buffers are only updated if they are to be tracked and we are in training mode. Thus they only need to be
-    passed when the update should occur (i.e. in training mode when they are tracked), or when buffer stats are
-    used for normalization (i.e. in eval mode when buffers are not None).
-    """
-    return F.batch_norm(
-        input,
-        # If buffers are not to be tracked, ensure that they won't be updated
-        (
-            self.running_mean
-            if not self.training or self.track_running_stats
-            else None
-        ),
-        self.running_var if not self.training or self.track_running_stats else None,
-        self.weight,
-        self.bias,
-        bn_training,
-        exponential_average_factor,
-        self.eps,
-    ).to(original_dtype)

training/unsloth_compiled_cache/BlockDiagonalLinear_peft_forward.py

@@ -1,85 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from unsloth_zoo.temporary_patches.common import torch_compile
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from peft.tuners.lora.variants import (F, torch)
-
-
-torch_addmm = torch.addmm
-torch_add   = torch.add
-torch_is_compiling = torch.compiler.is_compiling
-# torch 2.8 / 2.9 inductor miscompiles addmm(alpha = scaling, beta = 1) traced inside a
-# compiled block (e.g. the VLM decoder MLP), forward and backward; fixed in 2.10 (unsloth#3271).
-torch_lora_no_compiled_addmm = tuple(int(v) for v in torch.__version__.split(".")[:2]) < (2, 10)
-# @torch.compile(fullgraph = False, dynamic = True, options = torch_compile_options)
-def lora_forward(result, lora_A, lora_B, dropout, x, scaling):
-    # Use result.dtype (bfloat16 from base layer) since x may have been cast to float32
-    # by _cast_input_dtype when autocast is disabled
-    target_dtype = result.dtype
-    xA = dropout(x).to(target_dtype) @ lora_A.weight.to(target_dtype).t()
-    if torch_lora_no_compiled_addmm and torch_is_compiling():
-        output = result + scaling * (xA @ lora_B.weight.to(target_dtype).t())
-        bias = lora_B.bias
-        if bias is not None:
-            output = output + scaling * bias.to(target_dtype)
-        return output
-    # output = result + scaling * xA @ lora_B.weight.t()
-    shape = result.shape
-    output = torch_addmm(
-        result.view(-1, shape[-1]),
-        xA.view(-1, xA.shape[-1]),
-        lora_B.weight.to(target_dtype).t(),
-        alpha = scaling,
-        beta = 1,
-    ).view(shape)
-
-    bias = lora_B.bias
-    if bias is not None:
-        output = torch_add(
-            output,
-            bias.to(target_dtype),
-            alpha = scaling,
-        )
-    return output
-pass
-
-def unsloth_forward(self, x: torch.Tensor) -> torch.Tensor:
-    first_dims = x.shape[:-1]
-    if x.dim() != 2:
-        x = x.reshape(-1, x.shape[-1])
-    B = x.shape[0]
-    nb = self.nblocks
-    m = x.shape[-1] // nb
-    n = self.out_features // nb
-    x = x.reshape(B, nb, m)
-    w = self.weight.view(nb, n, m)
-    out = torch.einsum("bim,inm->bin", x, w)
-    return out.reshape(*first_dims, -1)

training/unsloth_compiled_cache/Conv1d.py

@@ -1,104 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    return self._conv_forward(input, self.weight, self.bias).to(original_dtype)

training/unsloth_compiled_cache/Conv2d.py

@@ -1,104 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    return self._conv_forward(input, self.weight, self.bias).to(original_dtype)

training/unsloth_compiled_cache/Conv3d.py

@@ -1,104 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np)
-
-def forward(self, input: Tensor) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    return self._conv_forward(input, self.weight, self.bias).to(original_dtype)

training/unsloth_compiled_cache/ConvTranspose1d.py

@@ -1,132 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor, output_size: list[int] | None = None) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    if self.padding_mode != "zeros":
-        raise ValueError(
-            "Only `zeros` padding mode is supported for ConvTranspose1d"
-        )
-
-    if not isinstance(self.padding, tuple):
-        raise AssertionError("self.padding must be a tuple")
-    # One cannot replace List by Tuple or Sequence in "_output_padding" because
-    # TorchScript does not support `Sequence[T]` or `Tuple[T, ...]`.
-    num_spatial_dims = 1
-    output_padding = self._output_padding(
-        input,
-        output_size,
-        self.stride,  # type: ignore[arg-type]
-        self.padding,  # type: ignore[arg-type]
-        self.kernel_size,  # type: ignore[arg-type]
-        num_spatial_dims,
-        self.dilation,  # type: ignore[arg-type]
-    )
-    return F.conv_transpose1d(
-        input,
-        self.weight,
-        self.bias,
-        self.stride,
-        self.padding,
-        output_padding,
-        self.groups,
-        self.dilation,
-    ).to(original_dtype)

training/unsloth_compiled_cache/ConvTranspose2d.py

@@ -1,141 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor, output_size: list[int] | None = None) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    """
-    Performs the forward pass.
-
-    Attributes:
-        input (Tensor): The input tensor.
-        output_size (list[int], optional): A list of integers representing
-            the size of the output tensor. Default is None.
-    """
-    if self.padding_mode != "zeros":
-        raise ValueError(
-            "Only `zeros` padding mode is supported for ConvTranspose2d"
-        )
-
-    if not isinstance(self.padding, tuple):
-        raise AssertionError("self.padding must be a tuple")
-    # One cannot replace List by Tuple or Sequence in "_output_padding" because
-    # TorchScript does not support `Sequence[T]` or `Tuple[T, ...]`.
-    num_spatial_dims = 2
-    output_padding = self._output_padding(
-        input,
-        output_size,
-        self.stride,  # type: ignore[arg-type]
-        self.padding,  # type: ignore[arg-type]
-        self.kernel_size,  # type: ignore[arg-type]
-        num_spatial_dims,
-        self.dilation,  # type: ignore[arg-type]
-    )
-
-    return F.conv_transpose2d(
-        input,
-        self.weight,
-        self.bias,
-        self.stride,
-        self.padding,
-        output_padding,
-        self.groups,
-        self.dilation,
-    ).to(original_dtype)

training/unsloth_compiled_cache/ConvTranspose3d.py

@@ -1,133 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-import os
-import sys
-import torch
-import importlib.util
-import math
-if importlib.util.find_spec("unsloth_studio") is None:
-    UNSLOTH_STUDIO_ENABLED = False
-else:
-    UNSLOTH_STUDIO_ENABLED = os.environ.get("UNSLOTH_STUDIO_DISABLED", "0") == "0"
-pass
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-import math
-
-UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") == "1"
-UNSLOTH_ENABLE_CCE = os.environ.get("UNSLOTH_ENABLE_CCE", "1") == "1"
-UNSLOTH_COMPILE_DISABLE = os.environ.get("UNSLOTH_COMPILE_DISABLE", "0") in ("1", "partial",)
-UNSLOTH_COMPILE_LOCATION = os.environ.get("UNSLOTH_COMPILE_LOCATION", "unsloth_compiled_cache")
-if UNSLOTH_COMPILE_LOCATION not in sys.path:
-    sys.path.insert(0, UNSLOTH_COMPILE_LOCATION)
-
-import logging
-logger_compiler = logging.getLogger(__name__)
-if UNSLOTH_ENABLE_LOGGING:
-    logger_compiler.setLevel(logging.DEBUG)
-
-global INFERENCE_RUNS
-INFERENCE_RUNS = 0
-
-try:
-    import torch._dynamo.eval_frame as torch_dynamo_eval_frame
-    torch_dynamo_eval_frame._stance.stance
-    torch_compiler_set_stance = torch.compiler.set_stance
-except:
-    torch_dynamo_eval_frame = None
-    torch_compiler_set_stance = None
-pass
-
-# The stance is process wide, so whether Unsloth owns it lives in unsloth_zoo, shared by
-# every generated module: inference in one model's module, training in another's.
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_EAGER_STANCE_OWNED, unsloth_claim_eager_stance, unsloth_owns_stance, unsloth_release_stance
-
-def unsloth_training_stance():
-    # eager_on_recompile is global: left on by generate() or eval forwards, every recompile
-    # in a later training step (new sequence length, model.train() without for_training)
-    # would silently run the eager body. Training forwards restore the default stance,
-    # unless the user chose eager_on_recompile themselves. Every set_stance call installs a
-    # fresh stance object, so ours is still active only if the current one `is` it; a user
-    # set_stance since then (even to eager_on_recompile again) is theirs and stays.
-    global INFERENCE_RUNS
-    INFERENCE_RUNS = 0
-    if len(UNSLOTH_EAGER_STANCE_OWNED) != 0 and torch_dynamo_eval_frame is not None:
-        current = torch_dynamo_eval_frame._stance
-        # Ownership is only dropped once ours is reset: a temporary stance scope's exit restores
-        # one of our exact objects, which a later training forward must still recognise.
-        if current.stance == "eager_on_recompile" and unsloth_owns_stance(current):
-            # Only the reset object: an outer scope may still restore another one of ours.
-            # Put back what the caller had before Unsloth switched (force_eager, a backend, ...).
-            previous = unsloth_release_stance(current)
-            if previous is not None and hasattr(torch_dynamo_eval_frame, "_set_stance"):
-                torch_dynamo_eval_frame._set_stance(previous)
-            else:
-                torch_compiler_set_stance(stance = "default", skip_guard_eval_unsafe = False)
-pass
-
-from unsloth_zoo import DEVICE_TYPE_TORCH, DEVICE_COUNT
-from unsloth_zoo.temporary_patches.utils import UNSLOTH_DECODE_COMPILE
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from transformers.models.siglip.modeling_siglip import (np, nn)
-
-def forward(self, input: Tensor, output_size: list[int] | None = None) -> Tensor:
-    original_dtype = input.dtype
-    input = input.to(self.weight.dtype)
-    if self.padding_mode != "zeros":
-        raise ValueError(
-            "Only `zeros` padding mode is supported for ConvTranspose3d"
-        )
-
-    if not isinstance(self.padding, tuple):
-        raise AssertionError("self.padding must be a tuple")
-    # One cannot replace List by Tuple or Sequence in "_output_padding" because
-    # TorchScript does not support `Sequence[T]` or `Tuple[T, ...]`.
-    num_spatial_dims = 3
-    output_padding = self._output_padding(
-        input,
-        output_size,
-        self.stride,  # type: ignore[arg-type]
-        self.padding,  # type: ignore[arg-type]
-        self.kernel_size,  # type: ignore[arg-type]
-        num_spatial_dims,
-        self.dilation,  # type: ignore[arg-type]
-    )
-
-    return F.conv_transpose3d(
-        input,
-        self.weight,
-        self.bias,
-        self.stride,
-        self.padding,
-        output_padding,
-        self.groups,
-        self.dilation,
-    ).to(original_dtype)

training/unsloth_compiled_cache/GPTQLoraLinear_peft_forward.py

@@ -1,106 +0,0 @@
-"""
-2026.10.9
-2026.10.9
-5.5.0
-1.15.0
-__UNSLOTH_VERSIONING__
-"""
-
-# Unsloth auto generated code
-# Copyright 2023-present Daniel Han-Chen, Michael Han-Chen & the Unsloth team. All rights reserved.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-torch_compile_options = {'epilogue_fusion': True, 'max_autotune': False, 'shape_padding': True, 'trace.enabled': False, 'triton.cudagraphs': False, 'debug': False, 'dce': True, 'memory_planning': True, 'coordinate_descent_tuning': False, 'trace.graph_diagram': False, 'compile_threads': 32, 'group_fusion': True, 'disable_progress': True, 'verbose_progress': False, 'triton.multi_kernel': 0, 'triton.use_block_ptr': False, 'triton.enable_persistent_tma_matmul': False, 'triton.autotune_at_compile_time': False, 'triton.cooperative_reductions': False, 'cuda.compile_opt_level': '-O2', 'cuda.enable_cuda_lto': True, 'combo_kernels': False, 'benchmark_combo_kernel': True, 'combo_kernel_foreach_dynamic_shapes': True}
-from torch import Tensor
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from unsloth_zoo.temporary_patches.common import torch_compile
-from typing import Any, List, Optional, Tuple, Union, Dict, Set, Callable
-from peft.tuners.lora.gptq import (torch)
-
-
-torch_addmm = torch.addmm
-torch_add   = torch.add
-torch_is_compiling = torch.compiler.is_compiling
-# torch 2.8 / 2.9 inductor miscompiles addmm(alpha = scaling, beta = 1) traced inside a
-# compiled block (e.g. the VLM decoder MLP), forward and backward; fixed in 2.10 (unsloth#3271).
-torch_lora_no_compiled_addmm = tuple(int(v) for v in torch.__version__.split(".")[:2]) < (2, 10)
-# @torch.compile(fullgraph = False, dynamic = True, options = torch_compile_options)
-def lora_forward(result, lora_A, lora_B, dropout, x, scaling):
-    # Use result.dtype (bfloat16 from base layer) since x may have been cast to float32
-    # by _cast_input_dtype when autocast is disabled
-    target_dtype = result.dtype
-    xA = dropout(x).to(target_dtype) @ lora_A.weight.to(target_dtype).t()
-    if torch_lora_no_compiled_addmm and torch_is_compiling():
-        output = result + scaling * (xA @ lora_B.weight.to(target_dtype).t())
-        bias = lora_B.bias
-        if bias is not None:
-            output = output + scaling * bias.to(target_dtype)
-        return output
-    # output = result + scaling * xA @ lora_B.weight.t()
-    shape = result.shape
-    output = torch_addmm(
-        result.view(-1, shape[-1]),
-        xA.view(-1, xA.shape[-1]),
-        lora_B.weight.to(target_dtype).t(),
-        alpha = scaling,
-        beta = 1,
-    ).view(shape)
-
-    bias = lora_B.bias
-    if bias is not None:
-        output = torch_add(
-            output,
-            bias.to(target_dtype),
-            alpha = scaling,
-        )
-    return output
-pass
-
-def unsloth_forward(self, x: torch.Tensor):
-    # note: logic differs from default Linear because merging is not supported
-    result = self.quant_linear_module(x)
-
-    if self.disable_adapters:
-        return result
-
-    lora_A_keys = self.lora_A.keys()
-
-    for active_adapter in self.active_adapters:
-        if active_adapter not in lora_A_keys:
-            continue
-        torch_result_dtype = result.dtype
-
-        lora_A = self.lora_A[active_adapter]
-        lora_B = self.lora_B[active_adapter]
-        dropout = self.lora_dropout[active_adapter]
-        scaling = self.scaling[active_adapter]
-
-        if not torch.is_autocast_enabled(): result, x = result.to(lora_A.weight.dtype), x.to(lora_A.weight.dtype)
-
-        if active_adapter not in self.lora_variant:  # vanilla LoRA
-            return lora_forward(result, lora_A, lora_B, dropout, x, scaling).to(torch_result_dtype)
-        else:
-            result = self.lora_variant[active_adapter].forward(
-                self,
-                active_adapter=active_adapter,
-                x=x,
-                result=result,
-            )
-
-        result = result.to(torch_result_dtype)
-    return result