Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Static denoiser profile (repeated blocks, graph-break screen) that only describes; registered
families keep their decisions; cached by class, forward digest and diffusers version"""
from __future__ import annotations
import re
import threading
from dataclasses import dataclass, field
from typing import Any, Optional
from .patches import source_digest
# Host-sync / data-dependent constructs that break a dynamo graph (zoo compiler.py screens the same set).
GRAPH_BREAK_PATTERNS: tuple[tuple[str, str], ...] = (
(".item()", r"\.item\(\s*\)"),
(".tolist()", r"\.tolist\(\s*\)"),
(".nonzero()", r"\.nonzero\(|torch\.nonzero\("),
(".cpu()", r"\.cpu\(\s*\)"),
(".numpy()", r"\.numpy\(\s*\)"),
("torch.unique", r"torch\.unique\(|\.unique\(\s*\)"),
("bincount", r"\.bincount\(|torch\.bincount\("),
("masked_select", r"masked_select\("),
("print", r"(?<![\w.])print\("),
)
_COMPILED_PATTERNS = tuple((label, re.compile(rx)) for label, rx in GRAPH_BREAK_PATTERNS)
_DISPATCH_RX = re.compile(r"dispatch_attention_fn\(")
_SDPA_RX = re.compile(r"scaled_dot_product_attention\(")
_STREAM_MERGE_RX = re.compile(
r"torch\.cat\(\s*\[\s*(?:encoder_hidden_states\s*,\s*hidden_states"
r"|hidden_states\s*,\s*encoder_hidden_states)\s*\]"
)
@dataclass(frozen = True)
class BlockProfile:
name: str
count: int
digest: Optional[str]
graph_break_suspects: tuple[str, ...] = ()
merges_streams: bool = False
@dataclass(frozen = True)
class ModelProfile:
class_name: str
qualname: str
digest: Optional[str]
diffusers_version: str
declared_blocks: tuple[str, ...] = ()
verified_blocks: tuple[str, ...] = ()
discovered_blocks: tuple[str, ...] = ()
blocks: tuple[BlockProfile, ...] = field(default_factory = tuple)
uses_dispatcher: Optional[bool] = None
calls_sdpa_directly: bool = False
has_compile_repeated_blocks: bool = False
@property
def repeated_blocks(self) -> tuple[str, ...]:
"""What the regional compile will use: declared, else verified-and-present (Studio's ensure_repeated_blocks)."""
if self.declared_blocks:
return self.declared_blocks
return tuple(n for n in self.verified_blocks if n in self.discovered_blocks)
@property
def graph_break_suspects(self) -> dict[str, tuple[str, ...]]:
return {b.name: b.graph_break_suspects for b in self.blocks if b.graph_break_suspects}
def compile_decline(self) -> Optional[str]:
"""Why a regional compile cannot engage on this class, or None."""
if not self.has_compile_repeated_blocks:
return "denoiser has no compile_repeated_blocks (not a diffusers ModelMixin)"
if self.repeated_blocks:
return None
if self.discovered_blocks:
return (
"declares no _repeated_blocks; discovered "
+ ", ".join(self.discovered_blocks)
+ " but they are not verified for regional compile"
)
return "declares no _repeated_blocks and none were discovered"
def as_dict(self) -> dict:
return {
"class": self.class_name,
"digest": self.digest,
"diffusers": self.diffusers_version,
"repeated_blocks": list(self.repeated_blocks),
"declared_blocks": list(self.declared_blocks),
"discovered_blocks": list(self.discovered_blocks),
"uses_dispatcher": self.uses_dispatcher,
"graph_break_suspects": {k: list(v) for k, v in self.graph_break_suspects.items()},
"merges_streams": [b.name for b in self.blocks if b.merges_streams],
}
_CACHE: dict[tuple, ModelProfile] = {}
_LOCK = threading.Lock()
def _diffusers_version() -> str:
try:
import diffusers # noqa: PLC0415
return str(getattr(diffusers, "__version__", "unknown"))
except Exception: # noqa: BLE001
return "unavailable"
def _source(fn: Any) -> Optional[str]:
try:
import inspect # noqa: PLC0415
return inspect.getsource(fn)
except Exception: # noqa: BLE001
return None
def screen_source(source: Optional[str]) -> tuple[str, ...]:
"""Graph-break suspects in ``source`` (labels of :data:`GRAPH_BREAK_PATTERNS`), comment lines ignored."""
if not source:
return ()
code = "\n".join(line.split("#", 1)[0] for line in source.splitlines())
return tuple(label for label, rx in _COMPILED_PATTERNS if rx.search(code))
def _block_classes(model: Any, names: tuple[str, ...]) -> dict[str, tuple[type, int]]:
out: dict[str, tuple[type, int]] = {}
modules = getattr(model, "modules", None)
if not callable(modules) or not names:
return out
try:
for sub in modules():
cls = type(sub)
if cls.__name__ in names:
prev = out.get(cls.__name__)
out[cls.__name__] = (cls, (prev[1] if prev else 0) + 1)
except Exception: # noqa: BLE001 - a probe, never a failed load
return {}
return out
def profile_model(model: Any) -> Optional[ModelProfile]:
"""Profile ``model``'s class (cached). None for a non-module (stubs, views)."""
if model is None:
return None
cls = type(model)
forward = getattr(cls, "forward", None)
key = (
f"{cls.__module__}.{cls.__qualname__}",
source_digest(forward) if forward else None,
_diffusers_version(),
)
with _LOCK:
cached = _CACHE.get(key)
if cached is not None:
return cached
declared = tuple(getattr(cls, "_repeated_blocks", None) or ())
try:
from ..diffusion_regional_compile import discover_repeated_blocks, verified_repeated_blocks # noqa: PLC0415
verified = tuple(verified_repeated_blocks(cls.__name__))
discovered = tuple(discover_repeated_blocks(model))
except Exception: # noqa: BLE001
verified, discovered = (), ()
names = declared or verified or discovered
blocks = []
for name, (bcls, count) in _block_classes(model, names).items():
src = _source(getattr(bcls, "forward", None))
blocks.append(
BlockProfile(
name = name,
count = count,
digest = source_digest(getattr(bcls, "forward", None)),
graph_break_suspects = screen_source(src),
merges_streams = bool(src and _STREAM_MERGE_RX.search(src)),
)
)
module_src = None
try:
import sys # noqa: PLC0415
mod = sys.modules.get(cls.__module__)
module_src = _source(mod) if mod is not None else None
except Exception: # noqa: BLE001
module_src = None
profile = ModelProfile(
class_name = cls.__name__,
qualname = key[0],
digest = key[1],
diffusers_version = key[2],
declared_blocks = declared,
verified_blocks = verified,
discovered_blocks = discovered,
blocks = tuple(sorted(blocks, key = lambda b: b.name)),
uses_dispatcher = bool(_DISPATCH_RX.search(module_src)) if module_src else None,
calls_sdpa_directly = bool(module_src and _SDPA_RX.search(module_src)),
has_compile_repeated_blocks = callable(getattr(model, "compile_repeated_blocks", None)),
)
with _LOCK:
_CACHE[key] = profile
return profile
def clear_cache() -> None:
with _LOCK:
_CACHE.clear()