triton-windows 3.3.0.post19__cp313-cp313-win_amd64.whl → 3.4.0.post20__cp313-cp313-win_amd64.whl

triton/runtime/build.py

@@ -1,14 +1,25 @@
+from __future__ import annotations
+
 import functools
-import sysconfig
+import hashlib
+import importlib.util
+import logging
 import os
 import shutil
 import subprocess
+import sysconfig
+import tempfile
+
+from types import ModuleType
+
+from .cache import get_cache_manager
+from .. import knobs
 
 if os.name == "nt":
     from triton.windows_utils import find_msvc_winsdk, find_python
 
 
-@functools.cache
+@functools.lru_cache
 def get_cc():
     cc = os.environ.get("CC")
     if cc is None:
@@ -30,6 +41,11 @@ def get_cc():
     return cc
 
 
+def is_tcc(cc):
+    cc = os.path.basename(cc).lower()
+    return cc == "tcc" or cc == "tcc.exe"
+
+
 def is_msvc(cc):
     cc = os.path.basename(cc).lower()
     return cc == "cl" or cc == "cl.exe"
@@ -58,13 +74,18 @@ def _cc_cmd(cc, src, out, include_dirs, library_dirs, libraries):
         if not (os.name == "nt" and is_clang(cc)):
             # Clang does not support -fPIC on Windows
             cc_cmd += ["-fPIC"]
+        if is_tcc(cc):
+            cc_cmd += ["-D_Py_USE_GCC_BUILTIN_ATOMICS"]
         cc_cmd += [f'-l{lib}' for lib in libraries]
         cc_cmd += [f"-L{dir}" for dir in library_dirs]
         cc_cmd += [f"-I{dir}" for dir in include_dirs if dir is not None]
     return cc_cmd
 
 
-def _build(name, src, srcdir, library_dirs, include_dirs, libraries):
+def _build(name: str, src: str, srcdir: str, library_dirs: list[str], include_dirs: list[str],
+           libraries: list[str]) -> str:
+    if impl := knobs.build.impl:
+        return impl(name, src, srcdir, library_dirs, include_dirs, libraries)
     suffix = sysconfig.get_config_var('EXT_SUFFIX')
     so = os.path.join(srcdir, '{name}{suffix}'.format(name=name, suffix=suffix))
     # try to avoid setuptools if possible
@@ -73,24 +94,25 @@ def _build(name, src, srcdir, library_dirs, include_dirs, libraries):
     if hasattr(sysconfig, 'get_default_scheme'):
         scheme = sysconfig.get_default_scheme()
     else:
-        scheme = sysconfig._get_default_scheme()
+        scheme = sysconfig._get_default_scheme()  # type: ignore
     # 'posix_local' is a custom scheme on Debian. However, starting Python 3.10, the default install
     # path changes to include 'local'. This change is required to use triton with system-wide python.
     if scheme == 'posix_local':
         scheme = 'posix_prefix'
     py_include_dir = sysconfig.get_paths(scheme=scheme)["include"]
-    custom_backend_dirs = set(os.getenv(var) for var in ('TRITON_CUDACRT_PATH', 'TRITON_CUDART_PATH'))
+    custom_backend_dirs = knobs.build.backend_dirs
+    # Don't append in place
     include_dirs = include_dirs + [srcdir, py_include_dir, *custom_backend_dirs]
     if os.name == "nt":
-        library_dirs += find_python()
-    # Link against Python stable ABI
-    # libraries is modified in place
-    if "python3" not in libraries:
-        libraries += ["python3"]
+        library_dirs = library_dirs + find_python()
+        version = sysconfig.get_python_version().replace(".", "")
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            version += "t"
+        libraries = libraries + [f"python{version}"]
     if is_msvc(cc):
         _, msvc_winsdk_inc_dirs, msvc_winsdk_lib_dirs = find_msvc_winsdk()
-        include_dirs += msvc_winsdk_inc_dirs
-        library_dirs += msvc_winsdk_lib_dirs
+        include_dirs = include_dirs + msvc_winsdk_inc_dirs
+        library_dirs = library_dirs + msvc_winsdk_lib_dirs
     cc_cmd = _cc_cmd(cc, src, so, include_dirs, library_dirs, libraries)
 
     try:
@@ -100,3 +122,45 @@ def _build(name, src, srcdir, library_dirs, include_dirs, libraries):
         raise e
 
     return so
+
+
+@functools.lru_cache
+def platform_key() -> str:
+    from platform import machine, system, architecture
+    return ",".join([machine(), system(), *architecture()])
+
+
+def _load_module_from_path(name: str, path: str) -> ModuleType:
+    # Loading module with relative path may cause error
+    path = os.path.abspath(path)
+    spec = importlib.util.spec_from_file_location(name, path)
+    if not spec or not spec.loader:
+        raise RuntimeError(f"Failed to load newly compiled {name} from {path}")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def compile_module_from_src(src: str, name: str, library_dirs: list[str] | None = None,
+                            include_dirs: list[str] | None = None, libraries: list[str] | None = None) -> ModuleType:
+    key = hashlib.sha256((src + platform_key()).encode("utf-8")).hexdigest()
+    cache = get_cache_manager(key)
+    suffix = sysconfig.get_config_var("EXT_SUFFIX")
+    cache_path = cache.get_file(f"{name}{suffix}")
+
+    if cache_path is not None:
+        try:
+            return _load_module_from_path(name, cache_path)
+        except (RuntimeError, ImportError):
+            log = logging.getLogger(__name__)
+            log.warning(f"Triton cache error: compiled module {name}.so could not be loaded")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        src_path = os.path.join(tmpdir, name + ".c")
+        with open(src_path, "w") as f:
+            f.write(src)
+        so = _build(name, src_path, tmpdir, library_dirs or [], include_dirs or [], libraries or [])
+        with open(so, "rb") as f:
+            cache_path = cache.put(f.read(), f"{name}{suffix}", binary=True)
+
+    return _load_module_from_path(name, cache_path)

triton/runtime/cache.py

@@ -1,33 +1,17 @@
-import importlib
 import json
 import os
 import uuid
 from abc import ABC, abstractmethod
-from pathlib import Path
 from typing import Dict, List, Optional
 import base64
 import hashlib
 
-
-def get_home_dir():
-    return os.getenv("TRITON_HOME", Path.home())
-
-
-def default_cache_dir():
-    return os.path.join(get_home_dir(), ".triton", "cache")
-
-
-def default_override_dir():
-    return os.path.join(get_home_dir(), ".triton", "override")
-
-
-def default_dump_dir():
-    return os.path.join(get_home_dir(), ".triton", "dump")
+from .. import knobs
 
 
 class CacheManager(ABC):
 
-    def __init__(self, key):
+    def __init__(self, key, override=False, dump=False):
         pass
 
     @abstractmethod
@@ -53,16 +37,16 @@ class FileCacheManager(CacheManager):
         self.key = key
         self.lock_path = None
         if dump:
-            self.cache_dir = os.getenv("TRITON_DUMP_DIR", "").strip() or default_dump_dir()
+            self.cache_dir = knobs.cache.dump_dir
             self.cache_dir = os.path.join(self.cache_dir, self.key)
             self.lock_path = os.path.join(self.cache_dir, "lock")
             os.makedirs(self.cache_dir, exist_ok=True)
         elif override:
-            self.cache_dir = os.getenv("TRITON_OVERRIDE_DIR", "").strip() or default_override_dir()
+            self.cache_dir = knobs.cache.override_dir
             self.cache_dir = os.path.join(self.cache_dir, self.key)
         else:
             # create cache directory if it doesn't exist
-            self.cache_dir = os.getenv("TRITON_CACHE_DIR", "").strip() or default_cache_dir()
+            self.cache_dir = knobs.cache.dir
             if self.cache_dir:
                 self.cache_dir = os.path.join(self.cache_dir, self.key)
                 self.lock_path = os.path.join(self.cache_dir, "lock")
@@ -166,10 +150,10 @@ class RedisRemoteCacheBackend(RemoteCacheBackend):
     def __init__(self, key):
         import redis
         self._key = key
-        self._key_fmt = os.environ.get("TRITON_REDIS_KEY_FORMAT", "triton:{key}:{filename}")
+        self._key_fmt = knobs.cache.redis.key_format
         self._redis = redis.Redis(
-            host=os.environ.get("TRITON_REDIS_HOST", "localhost"),
-            port=int(os.environ.get("TRITON_REDIS_PORT", 6379)),
+            host=knobs.cache.redis.host,
+            port=knobs.cache.redis.port,
         )
 
     def _get_key(self, filename: str) -> str:
@@ -187,10 +171,10 @@ class RemoteCacheManager(CacheManager):
 
     def __init__(self, key, override=False, dump=False):
         # Setup backend pointed too by `TRITON_REMOTE_CACHE_BACKEND`.
-        remote_cache_manager = os.environ["TRITON_REMOTE_CACHE_BACKEND"]
-        module_path, clz_nme = remote_cache_manager.split(":")
-        module = importlib.import_module(module_path)
-        remote_cache_cls = getattr(module, clz_nme)
+        remote_cache_cls = knobs.cache.remote_manager_class
+        if not remote_cache_cls:
+            raise RuntimeError(
+                "Unable to instantiate RemoteCacheManager, TRITON_REMOTE_CACHE_BACKEND doesn't point to a valid class")
         self._backend = remote_cache_cls(key)
 
         self._override = override
@@ -260,37 +244,24 @@ class RemoteCacheManager(CacheManager):
         return self.put(grp_contents, grp_filename)
 
 
-__cache_cls = FileCacheManager
-__cache_cls_nme = "DEFAULT"
-
-
 def _base32(key):
     # Assume key is a hex string.
     return base64.b32encode(bytes.fromhex(key)).decode("utf-8").rstrip("=")
 
 
 def get_cache_manager(key) -> CacheManager:
-    import os
-
-    user_cache_manager = os.environ.get("TRITON_CACHE_MANAGER", None)
-    global __cache_cls
-    global __cache_cls_nme
-
-    if user_cache_manager is not None and user_cache_manager != __cache_cls_nme:
-        module_path, clz_nme = user_cache_manager.split(":")
-        module = importlib.import_module(module_path)
-        __cache_cls = getattr(module, clz_nme)
-        __cache_cls_nme = user_cache_manager
-
-    return __cache_cls(_base32(key))
+    cls = knobs.cache.manager_class or FileCacheManager
+    return cls(_base32(key))
 
 
 def get_override_manager(key) -> CacheManager:
-    return __cache_cls(_base32(key), override=True)
+    cls = knobs.cache.manager_class or FileCacheManager
+    return cls(_base32(key), override=True)
 
 
 def get_dump_manager(key) -> CacheManager:
-    return __cache_cls(_base32(key), dump=True)
+    cls = knobs.cache.manager_class or FileCacheManager
+    return cls(_base32(key), dump=True)
 
 
 def make_so_cache_key(version_hash, signature, constants, ids, **kwargs):

triton/runtime/driver.py

@@ -1,59 +1,62 @@
-from ..backends import backends
-from ..backends import DriverBase
+from __future__ import annotations
 
+from ..backends import backends, DriverBase
 
-def _create_driver():
-    actives = [x.driver for x in backends.values() if x.driver.is_active()]
-    if len(actives) != 1:
-        raise RuntimeError(f"{len(actives)} active drivers ({actives}). There should only be one.")
-    return actives[0]()
+from typing import Any, Callable, Generic, TypeVar, Union
 
 
-class LazyProxy:
+def _create_driver() -> DriverBase:
+    active_drivers = [x.driver for x in backends.values() if x.driver.is_active()]
+    if len(active_drivers) != 1:
+        raise RuntimeError(f"{len(active_drivers)} active drivers ({active_drivers}). There should only be one.")
+    return active_drivers[0]()
 
-    def __init__(self, init_fn):
+
+T = TypeVar("T")
+
+
+class LazyProxy(Generic[T]):
+
+    def __init__(self, init_fn: Callable[[], T]) -> None:
         self._init_fn = init_fn
-        self._obj = None
+        self._obj: Union[T, None] = None
 
-    def _initialize_obj(self):
+    def _initialize_obj(self) -> T:
         if self._obj is None:
             self._obj = self._init_fn()
+        return self._obj
 
-    def __getattr__(self, name):
-        self._initialize_obj()
-        return getattr(self._obj, name)
+    def __getattr__(self, name) -> Any:
+        return getattr(self._initialize_obj(), name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name in ["_init_fn", "_obj"]:
             super().__setattr__(name, value)
         else:
-            self._initialize_obj()
-            setattr(self._obj, name, value)
+            setattr(self._initialize_obj(), name, value)
 
-    def __delattr__(self, name):
-        self._initialize_obj()
-        delattr(self._obj, name)
+    def __delattr__(self, name: str) -> None:
+        delattr(self._initialize_obj(), name)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self._obj is None:
             return f"<{self.__class__.__name__} for {self._init_fn} not yet initialized>"
         return repr(self._obj)
 
-    def __str__(self):
-        self._initialize_obj()
-        return str(self._obj)
+    def __str__(self) -> str:
+        return str(self._initialize_obj())
 
 
 class DriverConfig:
 
-    def __init__(self):
-        self.default = LazyProxy(_create_driver)
-        self.active = self.default
+    def __init__(self) -> None:
+        self.default: LazyProxy[DriverBase] = LazyProxy(_create_driver)
+        self.active: Union[LazyProxy[DriverBase], DriverBase] = self.default
 
-    def set_active(self, driver: DriverBase):
+    def set_active(self, driver: DriverBase) -> None:
         self.active = driver
 
-    def reset_active(self):
+    def reset_active(self) -> None:
         self.active = self.default
 
 

triton/runtime/interpreter.py

@@ -1,32 +1,36 @@
+from __future__ import annotations
 import ast
 import textwrap
 import inspect
-from typing import Tuple, List
+from typing import Tuple, List, Dict
 
 import math
 import numpy as np
 
 import triton
 import triton.language as tl
+import dataclasses
 from dataclasses import dataclass
+
+from triton.language.semantic import TritonSemantic
+from triton.tools.tensor_descriptor import TensorDescriptor
 from .errors import InterpreterError
 from functools import partial
 from .._C.libtriton import interpreter as _interpreter
 from .._C.libtriton import ir as _ir
 
 
+@dataclass
 class TensorHandle:
-
-    def __init__(self, data, dtype):
-        '''
-            data: numpy array
-            dtype: triton type, either pointer_type or scalar_type.
-            we don't store block_type here because the shape information is already available in the data field
-            attr: a dictionary of attributes
-        '''
-        self.data = data
-        self.dtype = dtype
-        self.attr = {}
+    '''
+        data: numpy array
+        dtype: triton type, either pointer_type or scalar_type.
+        we don't store block_type here because the shape information is already available in the data field
+        attr: a dictionary of attributes
+    '''
+    data: np.array
+    dtype: tl.dtype
+    attr: Dict = dataclasses.field(default_factory=dict)
 
     def __bool__(self):
         return bool(self.data.all())
@@ -103,6 +107,7 @@ class TensorDescHandle:
             off = (offsets[dim].data + np.arange(self.block_shape[dim])).reshape(bcast_dims)
             ptrs = ptrs + (itemsize * off * self.strides[dim].data).astype(np.uint64)
             masks = masks & (0 <= off) & (off < self.shape[dim].data)
+        assert ptrs.dtype == np.uint64
         ptrs = TensorHandle(ptrs, self.base.dtype.scalar)
         return ptrs, masks
 
@@ -114,7 +119,7 @@ class InterpreterOptions:
     sanitize_overflow: bool = True
     arch: str = None
     supported_fp8_dtypes: Tuple[str] = ("fp8e5", "fp8e5b16", "fp8e4nv", "fp8e4b8", "fp8e4b15")
-    deprecated_fp8_dtypes: Tuple[str] = ()
+    deprecated_fp8_dot_operand_dtypes: Tuple[str] = ()
     default_dot_input_precision: str = "tf32"
     allowed_dot_input_precisions: Tuple[str] = ("tf32", "tf32x3", "ieee")
     max_num_imprecise_acc_default: int = 0
@@ -248,8 +253,8 @@ np_umulhi_u64 = np.vectorize(_umulhi_64, otypes=[np.uint64])
 class ExtraFunctions:
 
     @staticmethod
-    def _convert_custom_types(input, dst_ty, fp_downcast_rounding, _builder):
-        return tl.tensor(_builder.create_fp_to_fp(input.handle, dst_ty, fp_downcast_rounding), dst_ty)
+    def _convert_custom_types(input, dst_ty, fp_downcast_rounding, _semantic):
+        return tl.tensor(_semantic.builder.create_fp_to_fp(input.handle, dst_ty, fp_downcast_rounding), dst_ty)
 
 
 class InterpreterBuilder:
@@ -306,6 +311,9 @@ class InterpreterBuilder:
     def get_double_ty(self):
         return tl.float64
 
+    def get_int1_ty(self):
+        return tl.int1
+
     def get_int8_ty(self):
         return tl.int8
 
@@ -587,11 +595,18 @@ class InterpreterBuilder:
             b_data = _convert_float(b_data, b.dtype, tl.float16, None).view(np.float16)
         return TensorHandle(np.matmul(a_data, b_data, dtype=d.data.dtype) + d.data, d.dtype.scalar)
 
-    def create_make_range(self, start, stop):
+    def create_make_range(self, ret_ty, start, stop):
         return TensorHandle(np.arange(start, stop, dtype=np.int32), tl.int32)
 
-    def create_histogram(self, data, bins):
-        return TensorHandle(np.histogram(data.data, bins=bins, range=(0, bins))[0], tl.int32)
+    def create_histogram(self, data, bins, mask):
+        if mask is None:
+            mask = TensorHandle(np.ones_like(data.data, dtype=bool), tl.int1)
+        # force all masked elements to zero
+        data = np.where(mask.data, data.data, np.zeros_like(data.data))
+        histogram = np.histogram(data, bins=bins, range=(0, bins))[0]
+        # remove overcounted elements
+        histogram[0] -= np.logical_not(mask.data).sum()
+        return TensorHandle(histogram, tl.int32)
 
     def create_gather(self, src, indices, axis):
         return TensorHandle(np.take_along_axis(src.data, indices.data, axis=axis), src.dtype.scalar)
@@ -641,7 +656,8 @@ class InterpreterBuilder:
         # Triton only supports splitting the original tensor into two along the last axis
         return (TensorHandle(val.data[..., 0], val.dtype.scalar), TensorHandle(val.data[..., 1], val.dtype.scalar))
 
-    def create_splat(self, arg, shape):
+    def create_splat(self, ret_ty, arg):
+        shape = ret_ty.shape
         if isinstance(arg.dtype, tl.block_type):
             return TensorHandle(np.full(shape, arg.data[0], dtype=_get_np_dtype(arg.dtype)), arg.dtype.scalar)
         else:  # scalar
@@ -715,6 +731,7 @@ class InterpreterBuilder:
         shape: List[TensorHandle],
         strides: List[TensorHandle],
         tensor_shape: List[int],
+        is_signed: bool,
     ):
         desc = TensorDescHandle(base, shape, strides, tensor_shape)
         desc.validate()
@@ -753,15 +770,18 @@ class InterpreterBuilder:
         np_type = _get_np_dtype(type)
         if "int" in np_type.name:
             return TensorHandle(np.full(1, -1, dtype=np_type), type.scalar)
+        elif np_type == np.bool_:
+            return TensorHandle(np.full(1, True, dtype=np_type), type.scalar)
         else:
             raise TypeError(f"unsupported type {type}")
 
 
 def _patch_attr(obj, name, member, builder):
+    semantic = TritonSemantic(builder)
     new_member = lambda *args, member=member, **kwargs: (member(*args, **
                                                                 {k: v
                                                                  for k, v in kwargs.items()
-                                                                 if k != "_builder"}, _builder=builder))
+                                                                 if k != "_semantic"}, _semantic=semantic))
     setattr(obj, name, new_member)
 
 
@@ -822,12 +842,10 @@ class ReduceScanOpInterface:
 
     def apply(self, input):
         if not isinstance(input, tuple):
-            input = (input, )
+            return self.apply((input, ))[0]
         self.check_tensor(input)
-        return self.apply_impl(input)
-
-    def apply_impl(self, input):
-        raise NotImplementedError("apply_impl not implemented")
+        ret = self.apply_impl(input)
+        return tuple(ret) if isinstance(ret, (list, tuple)) else (ret, )
 
 
 class ReduceOps(ReduceScanOpInterface):
@@ -887,7 +905,7 @@ class ReduceOps(ReduceScanOpInterface):
                 # Take a scalar
                 data = data.item()
             ret.append(self.to_tensor(data, input[i].dtype))
-        return ret[0] if len(ret) == 1 else tuple(ret)
+        return ret
 
     def min_max(self, input, val_reduce_op, idx_reduce_op=None):
         # If input is a tuple, it must be (val, index), and we only take val
@@ -985,7 +1003,7 @@ class ScanOps(ReduceScanOpInterface):
         if self.reverse:
             for arg in ret:
                 arg.handle.data = np.flip(arg.handle.data, axis=self.axis)
-        return len(ret) == 1 and ret[0] or tuple(ret)
+        return ret
 
 
 def _patch_reduce_scan():
@@ -1092,7 +1110,7 @@ def _patch_lang(fn):
             _patch_builtin(lang.math, interpreter_builder)
         _patch_lang_tensor(lang.tensor)
         _patch_lang_core(lang)
-    _patch_builtin(tl.core._experimental_tensor_descriptor_base, interpreter_builder)
+    _patch_builtin(tl.core.tensor_descriptor_base, interpreter_builder)
 
 
 def _tuple_create(arg, contents):
@@ -1127,10 +1145,22 @@ def _implicit_cvt(arg):
         return tl.tensor(handle, ty)
     elif isinstance(arg, tuple):
         return _tuple_create(arg, map(_implicit_cvt, arg))
+    elif isinstance(arg, TensorDescriptor):
+        strides = [_implicit_cvt(s) for s in arg.strides]
+        assert arg.strides[-1] == 1
+        strides[-1] = tl.constexpr(1)
+        semantic = TritonSemantic(InterpreterBuilder())
+        return semantic.make_tensor_descriptor(
+            base=_implicit_cvt(arg.base),
+            shape=[_implicit_cvt(s) for s in arg.shape],
+            strides=strides,
+            block_shape=[tl.constexpr(b) for b in arg.block_shape],
+        )
     return arg
 
 
 interpreter_builder = InterpreterBuilder()
+interpreter_semantic = TritonSemantic(interpreter_builder)
 
 
 def _unwrap_tensor(t):
@@ -1162,6 +1192,13 @@ class GridExecutor:
         def _to_cpu(arg):
             if isinstance(arg, tuple):
                 return _tuple_create(arg, map(_to_cpu, arg))
+            elif isinstance(arg, TensorDescriptor):
+                return TensorDescriptor(
+                    _to_cpu(arg.base),
+                    arg.shape,
+                    arg.strides,
+                    arg.block_shape,
+                )
             elif not hasattr(arg, "data_ptr"):
                 return arg
 
@@ -1195,6 +1232,8 @@ class GridExecutor:
             elif isinstance(arg_dev, tuple):
                 for (arg_dev, arg_hst) in zip(arg_dev, arg_hst):
                     _from_cpu(arg_dev, arg_hst)
+            elif isinstance(arg_dev, TensorDescriptor):
+                _from_cpu(arg_dev.base, arg_hst.base)
 
         for arg_dev, arg_hst in zip(args_dev, args_hst):
             _from_cpu(arg_dev, arg_hst)
@@ -1235,6 +1274,8 @@ class GridExecutor:
                         interpreter_builder.set_grid_idx(x, y, z)
                         self.fn(**args)
         except Exception as e:
+            if triton.knobs.compilation.front_end_debugging:
+                raise
             raise InterpreterError(repr(e)) from e
         # copy arguments back to propagate side-effects
         self._restore_args_dev(args_dev, args_hst, kwargs, kwargs_hst)
@@ -1249,14 +1290,10 @@ class ASTTransformer(ast.NodeTransformer):
         if len(names) > 1:
             raise ValueError("Multiple assignments are not supported")
         # Modify the assignment x = value to
-        # triton.language.semantic.to_tensor(value, interpreter_builder, False)
+        # interpreter_semantic.to_tensor(value, False)
         node.value = ast.Call(
-            func=ast.Attribute(
-                value=ast.Attribute(
-                    value=ast.Attribute(value=ast.Name(id='triton', ctx=ast.Load()), attr='language', ctx=ast.Load()),
-                    attr='semantic', ctx=ast.Load()), attr='to_tensor', ctx=ast.Load()),
-            args=[node.value, ast.Name(id='interpreter_builder', ctx=ast.Load()),
-                  ast.Constant(value=False)], keywords=[])
+            func=ast.Attribute(value=ast.Name(id="interpreter_semantic", ctx=ast.Load()), attr="to_tensor",
+                               ctx=ast.Load()), args=[node.value, ast.Constant(value=False)], keywords=[])
         return node