diff --git a/.bazelrc b/.bazelrc index a73cbf00a7..2075b15a70 100644 --- a/.bazelrc +++ b/.bazelrc @@ -193,6 +193,51 @@ build:arm --copt=-Wno-array-bounds # aios build:arm --copt=-Wno-unused-result # grpc build:arm --copt=-Wno-array-parameter # boringssl +build:xpu --copt="-DENABLE_BF16=1" +build:xpu --define=using_cuda=false --define=using_cuda_nvcc=false +build:xpu --define=using_xpu=true +build:xpu --copt="-DUSING_CUDA=0" +build:xpu --copt="-DUSING_XPU=1" +build:xpu --action_env TF_NEED_CUDA="0" +build:xpu --repo_env TF_NEED_XPU="1" +build:xpu --host_action_env TF_NEED_CUDA="0" +build:xpu --repo_env SYCL_TARGET="intel_gpu_pvc" +build:xpu --crosstool_top=@local_config_xpu//crosstool:toolchain +build:xpu --host_crosstool_top=@local_config_xpu//crosstool:toolchain +build:xpu --copt="-D_GLIBCXX_USE_CXX11_ABI=1" +build:xpu --action_env LIBRARY_PATH="/lib64:/usr/lib/x86_64-linux-gnu/" +build:xpu --host_action_env LIBRARY_PATH="/lib64:/usr/lib/x86_64-linux-gnu/" +build:xpu --per_file_copt=external/boringssl/.*@-Wno-array-parameter +build:xpu --per_file_copt=external/boringssl/.*@-Wno-error +build:xpu --copt="-Wno-unused-but-set-variable" +build:xpu --copt="-Wno-unused-private-field" +build:xpu --copt="-Wno-deprecated-builtins" +build:xpu --copt="-Wno-pessimizing-move" +build:xpu --copt="-Wno-unqualified-std-cast-call" +build:xpu --copt="-Wno-unused-value" +build:xpu --copt="-Wno-delete-non-abstract-non-virtual-dtor" +build:xpu --copt="-Wno-inconsistent-missing-override" +build:xpu --copt="-Wno-invalid-source-encoding" +build:xpu --copt="-Wno-unused-const-variable" +build:xpu --copt="-Wno-unknown-warning-option" +build:xpu --copt="-Wno-vla-cxx-extension" +build:xpu --copt="-Wno-deprecated-non-prototype" +build:xpu --copt="-Wno-array-parameter" +build:xpu --copt="-Wno-array-bounds" +build:xpu --copt="-Wno-error" # TODO(xpu): narrow to specific -Wno-xxx once icpx warnings are catalogued +build:xpu --host_copt="-Wno-error" # TODO(xpu): same as above +# Fix PYTHON_BIN_PATH for repository rules (xpu_configure.bzl). +# --action_env (line 8) only reaches build actions; repo rules need --repo_env. +# XPU containers symlink /opt/conda310/bin/python3 -> /opt/venv/bin/python3 +# (Python 3.12). This path is used here (rather than the venv path directly) +# because deps/pip.bzl must reference a path that exists in ALL container +# images -- pip_parse is evaluated unconditionally at WORKSPACE load time. +# xpu_configure.bzl resolves the symlink and validates Python == 3.12. +build:xpu --repo_env PYTHON_BIN_PATH="/opt/conda310/bin/python3" +build:xpu --python_top=@local_config_xpu//:python_runtime +build:xpu --action_env LD_LIBRARY_PATH="/lib64:/usr/lib/x86_64-linux-gnu/:/opt/intel/oneapi/compiler/latest/lib:/opt/intel/oneapi/compiler/latest/opt/compiler/lib" +build:xpu --host_action_env LD_LIBRARY_PATH="/lib64:/usr/lib/x86_64-linux-gnu/:/opt/intel/oneapi/compiler/latest/lib:/opt/intel/oneapi/compiler/latest/opt/compiler/lib" + # remote_kv_cache build:remote_kv_cache --define=use_remote_kv_cache=true @@ -215,6 +260,7 @@ build:asan --linkopt -fsanitize=address test:rocm --test_env PATH="/opt/rocm/bin:/opt/rh/gcc-toolset-12/root/usr/bin:/opt/conda310/bin:/opt/conda310/condabin:/usr/share/Modules/bin:/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/opt/cmake/cmake-3.26.4/bin" test:rocm --test_env LD_LIBRARY_PATH="/opt/rh/gcc-toolset-12/root/usr/lib64:/opt/rocm/lib:/opt/conda310/lib/:/usr/lib64:/opt/amdgpu/lib64" +test:xpu --test_env LD_LIBRARY_PATH="/lib64:/usr/lib/x86_64-linux-gnu/:/opt/intel/oneapi/compiler/latest/lib:/opt/intel/oneapi/compiler/latest/opt/compiler/lib:/opt/conda310/lib" test --test_env LD_LIBRARY_PATH="/opt/rocm/lib:/opt/conda310/lib/:/usr/local/nvidia/lib64:/usr/lib64:/usr/local/cuda/lib64:/opt/amdgpu/lib64:/usr/local/cuda/extras/CUPTI/lib64" test --test_env OMP_NUM_THREADS=8 test --test_env FT_SERVER_TEST="1" diff --git a/3rdparty/gpus/crosstool/clang/bin/crosstool_wrapper_driver_xpu.tpl b/3rdparty/gpus/crosstool/clang/bin/crosstool_wrapper_driver_xpu.tpl new file mode 100644 index 0000000000..9d93a77af0 --- /dev/null +++ b/3rdparty/gpus/crosstool/clang/bin/crosstool_wrapper_driver_xpu.tpl @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Crosstool wrapper for compiling with Intel oneAPI compilers (icx/icpx). + +SYNOPSIS: + crosstool_wrapper_driver_xpu [options passed in by cc_library() + or cc_binary() rule] + +DESCRIPTION: + This script is expected to be called by the cc_library() or cc_binary() bazel + rules. It routes compilation to Intel icx (C) or icpx (C++) compilers, + filtering out GCC-specific flags that are unsupported by the Intel toolchain. +""" + +from __future__ import print_function + +import os +import subprocess +import sys +import tempfile + +# Template values set by xpu_configure.bzl +ICX_PATH = '%{icx_path}' +ICPX_PATH = '%{icpx_path}' +ONEAPI_INCLUDE = '%{oneapi_include_path}' + +# GCC flags that icx/icpx do not support — silently dropped. +_UNSUPPORTED_FLAGS = frozenset([ + '-Wno-stringop-truncation', + '-Wno-stringop-overflow', + '-Wno-maybe-uninitialized', + '-Wno-format-overflow', + '-Wno-class-memaccess', + '-pass-exit-codes', +]) + +# Prefixes of GCC flags to drop (matched via startswith). +_UNSUPPORTED_PREFIXES = ( + '-Wformat-truncation=', + '-Wformat-overflow=', + '-Wstringop-truncation', + '-Wstringop-overflow=', +) + + +def _is_cpp(argv): + """Heuristic: if we see -x c++ or a .cpp/.cc/.cxx source, use icpx.""" + for i, arg in enumerate(argv): + # 'cu' kept for robustness — inherited from CUDA wrapper pattern + if arg == '-x' and i + 1 < len(argv) and argv[i + 1] in ('c++', 'cu'): + return True + if arg.endswith(('.cpp', '.cc', '.cxx', '.C')): + return True + return False + + +def _is_assembler(argv): + """Check if this is an assembler invocation.""" + for i, arg in enumerate(argv): + if arg == '-x' and i + 1 < len(argv) and argv[i + 1] in ('assembler', 'assembler-with-cpp'): + return True + if arg.endswith('.S'): + return True + return False + + +def _is_link_action(argv): + """Detect link actions: no -c (compile-only) flag present. + + C++ link actions don't pass -x c++ or .cc sources — only .o files and + linker flags — so _is_cpp() misses them. Since rtp-llm is a C++ project, + link actions should use icpx to ensure C++ runtime libraries are linked. + """ + return not any(arg == '-c' for arg in argv) + + +def _filter_flags(argv): + """Remove GCC-only flags that icx/icpx would reject.""" + filtered = [] + for arg in argv: + if arg in _UNSUPPORTED_FLAGS: + continue + if any(arg.startswith(p) for p in _UNSUPPORTED_PREFIXES): + continue + # icx does not support -mcpu=; map to -march= with the same value + # to preserve deterministic builds (avoid -march=native). + if arg.startswith('-mcpu='): + filtered.append('-march=' + arg[len('-mcpu='):]) + continue + filtered.append(arg) + return filtered + + +def _read_params_file(path): + """Read a Bazel @params file line-by-line. + + Bazel params files use one argument per line (multiline format). + Lines are read verbatim — no shell unquoting — to preserve arguments + that contain spaces, quotes, or other special characters exactly as + Bazel wrote them. + """ + args = [] + with open(path, 'r') as f: + for line in f: + line = line.rstrip('\n') + if line: + args.append(line) + return args + + +def _process_params_files(argv): + """Filter flags inside @params files and rewrite them. + + Instead of expanding all args inline (which risks hitting ARG_MAX), + this rewrites each @params file with filtered content and passes the + rewritten @file reference to the compiler. + + Returns (processed_argv, tmp_files) where tmp_files is the list of + temporary file paths created, so callers can clean them up. + """ + processed = [] + tmp_files = [] + for arg in argv: + if arg.startswith('@') and not arg.startswith('@rpath'): + params_file = arg[1:] + try: + params_args = _read_params_file(params_file) + params_args = _filter_flags(params_args) + # Write filtered args to a new params file (one per line, + # matching Bazel's multiline params format). + fd, tmp_path = tempfile.mkstemp( + prefix='xpu_params_', suffix='.txt') + with os.fdopen(fd, 'w') as tmp: + for a in params_args: + tmp.write(a + '\n') + tmp_files.append(tmp_path) + processed.append('@' + tmp_path) + except IOError: + print('WARNING: failed to read params file: ' + params_file, file=sys.stderr) + processed.append(arg) + else: + processed.append(arg) + return processed, tmp_files + + +def _collect_all_args(argv): + """Collect all arguments including those inside @params files. + + Returns a flat list of all args for language detection purposes. + The original @file references are preserved in argv for compilation. + """ + all_args = [] + for arg in argv: + if arg.startswith('@') and not arg.startswith('@rpath'): + try: + all_args.extend(_read_params_file(arg[1:])) + except IOError: + all_args.append(arg) + else: + all_args.append(arg) + return all_args + + +def main(): + argv = sys.argv[1:] + # Collect all args (including params file contents) for language detection + # BEFORE rewriting params files, so -x c++ and .cc sources are visible. + all_args_for_detection = _collect_all_args(argv) + argv, tmp_files = _process_params_files(argv) + try: + # Filter top-level flags (non-@params args) + argv = _filter_flags(argv) + + is_asm = _is_assembler(all_args_for_detection) + use_cxx = _is_cpp(all_args_for_detection) + + is_link = _is_link_action(all_args_for_detection) + + if use_cxx or is_link: + compiler = ICPX_PATH + extra = ['-isystem', ONEAPI_INCLUDE, '-include', 'cstdint'] if use_cxx else [] + elif is_asm: + compiler = ICX_PATH + extra = [] + else: + compiler = ICX_PATH + extra = ['-isystem', ONEAPI_INCLUDE, '-D_GNU_SOURCE', '-include', 'stdint.h', '-include', 'unistd.h'] + + cmd = [compiler] + extra + argv + return subprocess.call(cmd) + finally: + for f in tmp_files: + try: + os.unlink(f) + except OSError: + pass + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/3rdparty/gpus/crosstool/xpu_cc_toolchain_config.bzl.tpl b/3rdparty/gpus/crosstool/xpu_cc_toolchain_config.bzl.tpl new file mode 100644 index 0000000000..3c098a12fd --- /dev/null +++ b/3rdparty/gpus/crosstool/xpu_cc_toolchain_config.bzl.tpl @@ -0,0 +1,311 @@ +"""cc_toolchain_config rule for configuring Intel XPU (SYCL) toolchain on Linux.""" + +load( + "@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl", + "action_config", + "feature", + "feature_set", + "flag_group", + "flag_set", + "tool", + "tool_path", +) +load( + "@bazel_tools//tools/build_defs/cc:action_names.bzl", + "CC_FLAGS_MAKE_VARIABLE_ACTION_NAME", + "CPP_COMPILE_ACTION_NAME", + "CPP_HEADER_PARSING_ACTION_NAME", + "CPP_LINK_DYNAMIC_LIBRARY_ACTION_NAME", + "CPP_LINK_EXECUTABLE_ACTION_NAME", + "CPP_LINK_NODEPS_DYNAMIC_LIBRARY_ACTION_NAME", + "CPP_LINK_STATIC_LIBRARY_ACTION_NAME", + "CPP_MODULE_CODEGEN_ACTION_NAME", + "CPP_MODULE_COMPILE_ACTION_NAME", + "C_COMPILE_ACTION_NAME", + "LINKSTAMP_COMPILE_ACTION_NAME", + "LTO_BACKEND_ACTION_NAME", + "LTO_INDEXING_ACTION_NAME", + "PREPROCESS_ASSEMBLE_ACTION_NAME", + "STRIP_ACTION_NAME", +) + +ACTION_NAMES = struct( + c_compile = C_COMPILE_ACTION_NAME, + cpp_compile = CPP_COMPILE_ACTION_NAME, + linkstamp_compile = LINKSTAMP_COMPILE_ACTION_NAME, + cc_flags_make_variable = CC_FLAGS_MAKE_VARIABLE_ACTION_NAME, + cpp_module_codegen = CPP_MODULE_CODEGEN_ACTION_NAME, + cpp_header_parsing = CPP_HEADER_PARSING_ACTION_NAME, + cpp_module_compile = CPP_MODULE_COMPILE_ACTION_NAME, + preprocess_assemble = PREPROCESS_ASSEMBLE_ACTION_NAME, + lto_indexing = LTO_INDEXING_ACTION_NAME, + lto_backend = LTO_BACKEND_ACTION_NAME, + cpp_link_executable = CPP_LINK_EXECUTABLE_ACTION_NAME, + cpp_link_dynamic_library = CPP_LINK_DYNAMIC_LIBRARY_ACTION_NAME, + cpp_link_nodeps_dynamic_library = CPP_LINK_NODEPS_DYNAMIC_LIBRARY_ACTION_NAME, + cpp_link_static_library = CPP_LINK_STATIC_LIBRARY_ACTION_NAME, + strip = STRIP_ACTION_NAME, +) + +def _impl(ctx): + # Forced configuration paths optimized for Linux execution engines + toolchain_identifier = "local_linux" + host_system_name = "local" + target_system_name = "local" + target_cpu = "local" + target_libc = "local" + compiler = "compiler" + abi_version = "local" + abi_libc_version = "local" + + all_link_actions = [ + ACTION_NAMES.cpp_link_executable, + ACTION_NAMES.cpp_link_dynamic_library, + ACTION_NAMES.cpp_link_nodeps_dynamic_library, + ] + + action_configs = [] + + # Foundational compilation settings + supports_pic_feature = feature(name = "supports_pic", enabled = True) + supports_dynamic_linker_feature = feature(name = "supports_dynamic_linker", enabled = True) + supports_interface_shared_libraries_feature = feature(name = "supports_interface_shared_libraries", enabled = True) + + pic_feature = feature( + name = "pic", + enabled = True, + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [ + flag_group(flags = ["-fPIC"], expand_if_available = "pic"), + ], + ), + ], + ) + + # Core XPU and Ahead-of-Time SYCL Compilation Features + xpu_link_flags_feature = feature( + name = "xpu_link_flags", + enabled = True, + flag_sets = [ + flag_set( + actions = all_link_actions, + # -L points the linker at the directory where libze_loader.so was + # probed (it may live in oneAPI's lib dir, not a default search + # path); see xpu_configure.bzl ze_loader probe. + flag_groups = [flag_group(flags = ["-fsycl", "-L%{ze_loader_lib_dir}", "-lze_loader"])], + ), + ], + ) + + # Not enabled globally — only needed for SYCL kernel sources. + # Enable per-target: cc_library(features = ["xpu_sycl_compile"]) + xpu_sycl_compile_feature = feature( + name = "xpu_sycl_compile", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.cpp_compile], + flag_groups = [flag_group(flags = ["-fsycl", "-fsycl-targets=%{xpu_sycl_target}"])], + ), + ], + ) + + hardening_feature = feature(name = "hardening", flag_sets = []) + + opt_feature = feature( + name = "opt", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [flag_group(flags = ["-g0", "-O2", "-ffunction-sections", "-fdata-sections"])], + ), + flag_set( + actions = [ + ACTION_NAMES.cpp_link_dynamic_library, + ACTION_NAMES.cpp_link_nodeps_dynamic_library, + ACTION_NAMES.cpp_link_executable, + ], + flag_groups = [flag_group(flags = ["-Wl,--gc-sections"])], + ), + ], + implies = ["disable-assertions"], + ) + + dbg_feature = feature( + name = "dbg", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [flag_group(flags = ["-g"])], + ), + ], + ) + + disable_assertions_feature = feature( + name = "disable-assertions", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [flag_group(flags = ["-DNDEBUG"])], + ), + ], + ) + + fastbuild_feature = feature(name = "fastbuild") + + user_compile_flags_feature = feature( + name = "user_compile_flags", + flag_sets = [ + flag_set( + actions = [ + ACTION_NAMES.preprocess_assemble, + ACTION_NAMES.c_compile, + ACTION_NAMES.cpp_compile, + ACTION_NAMES.cpp_header_parsing, + ACTION_NAMES.cpp_module_compile, + ACTION_NAMES.cpp_module_codegen, + ], + flag_groups = [ + flag_group( + flags = ["%{user_compile_flags}"], + iterate_over = "user_compile_flags", + expand_if_available = "user_compile_flags", + ), + ], + ), + ], + ) + + unfiltered_flag_sets = [] + if ctx.attr.host_unfiltered_compile_flags: + unfiltered_flag_sets = [ + flag_set( + actions = [ + ACTION_NAMES.preprocess_assemble, + ACTION_NAMES.c_compile, + ACTION_NAMES.cpp_compile, + ACTION_NAMES.cpp_header_parsing, + ACTION_NAMES.cpp_module_compile, + ACTION_NAMES.cpp_module_codegen, + ], + flag_groups = [flag_group(flags = ctx.attr.host_unfiltered_compile_flags)], + ), + ] + + unfiltered_compile_flags_feature = feature( + name = "unfiltered_compile_flags", + flag_sets = unfiltered_flag_sets, + ) + + warnings_feature = feature( + name = "warnings", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [flag_group(flags = ["-Wall"] + ctx.attr.host_compiler_warnings)], + ), + ], + ) + + determinism_feature = feature( + name = "determinism", + flag_sets = [ + flag_set( + actions = [ACTION_NAMES.c_compile, ACTION_NAMES.cpp_compile], + flag_groups = [ + flag_group( + flags = [ + "-Wno-builtin-macro-redefined", + "-D__DATE__=\"redacted\"", + "-D__TIMESTAMP__=\"redacted\"", + "-D__TIME__=\"redacted\"", + ], + ), + ], + ), + ], + ) + + features = [ + supports_pic_feature, + supports_dynamic_linker_feature, + supports_interface_shared_libraries_feature, + pic_feature, + xpu_link_flags_feature, + xpu_sycl_compile_feature, + hardening_feature, + opt_feature, + dbg_feature, + disable_assertions_feature, + fastbuild_feature, + user_compile_flags_feature, + unfiltered_compile_flags_feature, + warnings_feature, + determinism_feature, + ] + + # Resolve compiler tool path directly using workspace discovery parameters + final_compiler_path = "/usr/bin/gcc" + if ctx.attr.host_compiler_path: + final_compiler_path = ctx.attr.host_compiler_path + + # Fallback guard clause to handle blank/missing compiler prefixes safely + prefix = "/usr/bin" + if ctx.attr.host_compiler_prefix: + prefix = ctx.attr.host_compiler_prefix + + tool_paths = [ + tool_path(name = "gcc", path = final_compiler_path), + tool_path(name = "ar", path = prefix + "/ar"), + tool_path(name = "compat-ld", path = prefix + "/ld"), + tool_path(name = "cpp", path = prefix + "/cpp"), + tool_path(name = "dwp", path = prefix + "/dwp"), + tool_path(name = "gcov", path = prefix + "/gcov"), + tool_path(name = "ld", path = prefix + "/ld"), + tool_path(name = "nm", path = prefix + "/nm"), + tool_path(name = "objcopy", path = prefix + "/objcopy"), + tool_path(name = "objdump", path = prefix + "/objdump"), + tool_path(name = "strip", path = prefix + "/strip"), + ] + + return cc_common.create_cc_toolchain_config_info( + ctx = ctx, + features = features, + action_configs = action_configs, + toolchain_identifier = toolchain_identifier, + host_system_name = host_system_name, + target_system_name = target_system_name, + target_cpu = target_cpu, + target_libc = target_libc, + compiler = compiler, + abi_version = abi_version, + abi_libc_version = abi_libc_version, + cxx_builtin_include_directories = ctx.attr.builtin_include_directories, + tool_paths = tool_paths, + ) + +cc_toolchain_config = rule( + implementation = _impl, + attrs = { + "cpu": attr.string(mandatory = True, values = ["local", "darwin", "x64_windows"]), + "host_compiler_warnings": attr.string_list(), + "host_unfiltered_compile_flags": attr.string_list(), + "builtin_include_directories": attr.string_list(), + "extra_no_canonical_prefixes_flags": attr.string_list(), + "host_compiler_path": attr.string(), + "host_compiler_prefix": attr.string(), + "linker_bin_path": attr.string(default = "/usr/bin"), + + # Stubs for deprecated parameters to stop the configuration engine from crashing + "msvc_cl_path": attr.string(default = ""), + "msvc_lib_path": attr.string(default = ""), + "msvc_link_path": attr.string(default = ""), + "msvc_ml_path": attr.string(default = ""), + "msvc_env_path": attr.string(default = ""), + "msvc_env_include": attr.string(default = ""), + "msvc_env_lib": attr.string(default = ""), + "msvc_env_tmp": attr.string(default = ""), + }, + provides = [CcToolchainConfigInfo], +) diff --git a/3rdparty/gpus/torch_xpu_configure.bzl b/3rdparty/gpus/torch_xpu_configure.bzl new file mode 100644 index 0000000000..4dec12205f --- /dev/null +++ b/3rdparty/gpus/torch_xpu_configure.bzl @@ -0,0 +1,117 @@ +"""Repository rule for torch XPU autoconfiguration. + +`torch_xpu_configure` depends on the following environment variables: + + * `PYTHON_BIN_PATH`: The python binary path. Used to detect site-packages. + +This rule creates a repository pointing at the system-installed PyTorch XPU +site-packages directory, detected automatically from the Python interpreter +on PATH or via `PYTHON_BIN_PATH`. +""" + +load("//3rdparty/gpus:xpu_python_utils.bzl", "resolve_venv_python") + +def _torch_xpu_configure_impl(repository_ctx): + # Check if XPU torch is actually available; if not, create a dummy repo + # so CUDA/ROCm builds don't fail. + python_bin = repository_ctx.os.environ.get("PYTHON_BIN_PATH", "") + if not python_bin: + python_bin = repository_ctx.which("python3") + if python_bin == None: + # No python3 — create dummy and return + repository_ctx.file("BUILD.bazel", "# dummy torch_xpu repo (no python3 found)\n") + return + python_bin = str(python_bin) + + # Resolve symlinked python to venv python so import torch works + python_bin = resolve_venv_python(repository_ctx, python_bin) + + # Check if torch.xpu is available in this Python + check = repository_ctx.execute([ + python_bin, "-c", "import torch; assert hasattr(torch, 'xpu')", + ]) + if check.return_code != 0: + # When XPU build is explicitly requested, fail instead of silently + # creating a stub — avoids hard-to-diagnose link errors later. + if repository_ctx.os.environ.get("TF_NEED_XPU", "0") == "1": + fail("TF_NEED_XPU=1 but torch.xpu is not available in " + python_bin + + " (exit code " + str(check.return_code) + ")" + + "\nstdout: " + check.stdout + + "\nstderr: " + check.stderr) + + # torch.xpu not available — create minimal stub BUILD so + # CUDA/ROCm builds don't fail on unresolvable dependencies. + repository_ctx.file("BUILD.bazel", """ +package(default_visibility = ["//visibility:public"]) +cc_library(name = "torch") +cc_library(name = "torch_api") +cc_library(name = "torch_libs") +""") + repository_ctx.file("torch/lib/.empty", "") + return + + # Auto-detect site-packages from the actual torch installation path. + # Using torch.__file__ instead of site.getsitepackages() avoids mismatches + # in venv/system-site-packages or custom sys.path configurations. + result = repository_ctx.execute([ + python_bin, + "-c", + "import torch, os; print(os.path.dirname(os.path.dirname(torch.__file__)))", + ]) + if result.return_code != 0: + fail("Failed to detect site-packages from torch.__file__: " + result.stderr) + + site_packages = result.stdout.strip() + + # When XPU is explicitly requested, verify the actual torch XPU runtime + # libraries are present (hasattr(torch, 'xpu') is true even on CPU-only + # torch). Fail fast at config time with a clear message instead of letting + # the build fail much later at link time. + if repository_ctx.os.environ.get("TF_NEED_XPU", "0") == "1": + torch_lib_dir = site_packages + "/torch/lib" + missing = [] + for so in ["libtorch_xpu.so", "libc10_xpu.so"]: + if not repository_ctx.path(torch_lib_dir + "/" + so).exists: + missing.append(so) + if missing: + fail("TF_NEED_XPU=1 but required torch XPU libraries are missing " + + "from " + torch_lib_dir + ": " + ", ".join(missing) + + ". Install a torch build with XPU support (torch==*+xpu).") + + # List site-packages entries and symlink each one into the repo root, + # reproducing the same layout as new_local_repository(path = site_packages). + ls_result = repository_ctx.execute([ + python_bin, "-c", + "import os, sys; print('\\n'.join(os.listdir(sys.argv[1])))", + site_packages, + ]) + if ls_result.return_code != 0: + fail("Failed to list site-packages: " + ls_result.stderr) + # Only symlink directories actually needed by BUILD.pytorch to reduce + # repository rule I/O and invalidation surface. + _needed = {"torch": True, "torch.libs": True, "torch.dist-info": True} + for entry in ls_result.stdout.strip().split("\n"): + if entry and (entry in _needed or entry.startswith("torch-") + or entry.startswith("torch_")): + repository_ctx.symlink(site_packages + "/" + entry, entry) + + # Generate BUILD file from the provided build_file (overwrites any + # symlinked BUILD that may exist in site-packages). + build_file = repository_ctx.attr.build_file + repository_ctx.symlink(build_file, "BUILD.bazel") + +torch_xpu_configure = repository_rule( + implementation = _torch_xpu_configure_impl, + attrs = { + "build_file": attr.label( + allow_single_file = True, + mandatory = True, + doc = "BUILD file for the torch XPU repository.", + ), + }, + environ = [ + "PYTHON_BIN_PATH", + "TF_NEED_XPU", + ], + doc = "Auto-detects PyTorch XPU site-packages and creates a repository.", +) diff --git a/3rdparty/gpus/xpu/BUILD b/3rdparty/gpus/xpu/BUILD new file mode 100644 index 0000000000..e69de29bb2 diff --git a/3rdparty/gpus/xpu/BUILD.tpl b/3rdparty/gpus/xpu/BUILD.tpl new file mode 100644 index 0000000000..e66328207a --- /dev/null +++ b/3rdparty/gpus/xpu/BUILD.tpl @@ -0,0 +1,53 @@ + +package(default_visibility = ["//visibility:public"]) + +config_setting( + name = "using_xpu", + values = { + "define": "using_xpu=true", + }, +) + +cc_library( + name = "xpu_headers", + hdrs = glob(["include/**"]), + includes = [ + ".", + "include", + "include/sycl", + ], + visibility = ["//visibility:public"], +) + +cc_library( + name = "sycl_runtime", + srcs = %{sycl_runtime_srcs}, + data = %{sycl_runtime_srcs}, + includes = [ + ".", + "include", + ], + linkstatic = 1, + visibility = ["//visibility:public"], +) + +cc_library( + name = "ze_loader", + srcs = %{ze_loader_srcs}, + data = %{ze_loader_srcs}, + linkstatic = 1, + visibility = ["//visibility:public"], +) + +# Meta-target: depend on this to get the full XPU runtime. +cc_library( + name = "xpu", + visibility = ["//visibility:public"], + deps = [ + ":xpu_headers", + ":sycl_runtime", + ":ze_loader", + ], +) + +%{copy_rules} diff --git a/3rdparty/gpus/xpu_configure.bzl b/3rdparty/gpus/xpu_configure.bzl new file mode 100644 index 0000000000..8e53b49439 --- /dev/null +++ b/3rdparty/gpus/xpu_configure.bzl @@ -0,0 +1,479 @@ +"""Repository rule for Intel XPU autoconfiguration. + +`xpu_configure` depends on the following environment variables: + + * `PYTHON_BIN_PATH`: The python binary path. Used to detect site-packages + for the torch_xpu repository. + * `ONEAPI_ROOT`: Path to Intel oneAPI installation. Default: /opt/intel/oneapi + * `SYCL_TARGET`: SYCL ahead-of-time compilation target. Default: spir64 + (JIT). Examples: intel_gpu_pvc, intel_gpu_bmg, spir64. +""" + +load("//3rdparty/gpus:xpu_python_utils.bzl", "resolve_venv_python") + +_ONEAPI_ROOT = "ONEAPI_ROOT" +_PYTHON_BIN_PATH = "PYTHON_BIN_PATH" +_SYCL_TARGET = "SYCL_TARGET" +_DEFAULT_SYCL_TARGET = "spir64" + +def _tpl(repository_ctx, tpl, substitutions = {}, out = None): + if not out: + out = tpl.replace(":", "/") + repository_ctx.template( + out, + Label("//3rdparty/gpus/%s.tpl" % tpl), + substitutions, + ) + +def to_list_of_strings(elements): + result = "" + for element in elements: + result += ("\"" + element + "\",") + return result + +def verify_build_defines(params): + """Verify all variables substituted into crosstool/BUILD are present.""" + missing = [] + pattern = [ + "%{cxx_builtin_include_directories}", + "%{extra_no_canonical_prefixes_flags}", + "%{host_compiler_path}", + "%{host_compiler_prefix}", + "%{host_compiler_warnings}", + "%{unfiltered_compile_flags}", + "%{linker_bin_path}", + "%{compiler_deps}", + "%{linker_files}", + "%{win_linker_files}", + "%{msvc_cl_path}", + "%{msvc_env_include}", + "%{msvc_env_lib}", + "%{msvc_env_path}", + "%{msvc_env_tmp}", + "%{msvc_lib_path}", + "%{msvc_link_path}", + "%{msvc_ml_path}", + ] + for p in pattern: + if p not in params: + missing.append(p) + if missing: + auto_configure_fail( + "crosstool/BUILD.tpl template is missing these variables: " + + str(missing) + + ". Are you using a modified BUILD.tpl? Please update it.") + +def auto_configure_fail(msg): + """Output failure message for auto configuration.""" + red = "\033[0;31m" + no_color = "\033[0m" + fail("\n%sAuto-Configuration Error:%s %s\n" % (red, no_color, msg)) + +def _cxx_inc_convert(path): + """Convert path returned by the compiler to its true path.""" + path = path.strip() + if path.startswith("("): + path = path.strip("()") + return path + +def _get_cxx_inc_directories_impl(repository_ctx, cc, lang_is_cpp): + """Get built-in include directories from compiler.""" + lang = "c++" if lang_is_cpp else "c" + result = repository_ctx.execute([cc, "-E", "-x" + lang, "-", "-v"]) + stderr = result.stderr + index1 = stderr.find("#include <...>") + if index1 == -1: + return [] + index1 = stderr.find("\n", index1) + if index1 == -1: + return [] + index2 = stderr.find("\n ", index1 + 1) + if index2 == -1: + return [] + index3 = stderr.find("End of search list", index2) + if index3 == -1: + return [] + inc_dirs = stderr[index2:index3] + return [ + repository_ctx.path(_cxx_inc_convert(p)) + for p in inc_dirs.split("\n") + if len(p.strip()) > 0 + ] + +def get_cxx_inc_directories(repository_ctx, cc): + """Compute the list of default C and C++ include directories.""" + includes_cpp = _get_cxx_inc_directories_impl(repository_ctx, cc, True) + includes_c = _get_cxx_inc_directories_impl(repository_ctx, cc, False) + includes_cpp_set = {str(d): None for d in includes_cpp} + return includes_cpp + [ + inc for inc in includes_c if str(inc) not in includes_cpp_set + ] + +def _oneapi_root(repository_ctx): + """Return the oneAPI root path.""" + oneapi_root = repository_ctx.os.environ.get(_ONEAPI_ROOT, "") + if oneapi_root: + # A stale/invalid ONEAPI_ROOT must not silently shadow a working default + # install. Validate the env-provided path before trusting it. + if not repository_ctx.path(oneapi_root).exists: + auto_configure_fail( + "ONEAPI_ROOT is set to '" + oneapi_root + "' but that path does " + + "not exist. Unset it to use a default install, or point it at a " + + "valid Intel oneAPI root.") + return oneapi_root + # Try common install locations + for path in ["/opt/intel/oneapi", "/opt/oneapi"]: + if repository_ctx.path(path).exists: + return path + auto_configure_fail( + "Cannot find Intel oneAPI. Set ONEAPI_ROOT environment variable " + + "or install to /opt/intel/oneapi.") + +def _find_icx(repository_ctx, oneapi_root): + """Find icx compiler path.""" + candidate = oneapi_root + "/compiler/latest/bin/icx" + if repository_ctx.path(candidate).exists: + return candidate + icx = repository_ctx.which("icx") + if icx != None: + return str(icx) + auto_configure_fail("Cannot find icx compiler. Ensure Intel oneAPI is installed.") + +def _find_icpx(repository_ctx, oneapi_root): + """Find icpx compiler path.""" + candidate = oneapi_root + "/compiler/latest/bin/icpx" + if repository_ctx.path(candidate).exists: + return candidate + icpx = repository_ctx.which("icpx") + if icpx != None: + return str(icpx) + auto_configure_fail("Cannot find icpx compiler. Ensure Intel oneAPI is installed.") + +def _get_sycl_target(repository_ctx): + """Get the SYCL ahead-of-time compilation target.""" + return repository_ctx.os.environ.get(_SYCL_TARGET, _DEFAULT_SYCL_TARGET) + +def _enable_xpu(repository_ctx): + """Check if XPU build is requested via TF_NEED_XPU env var and oneAPI is available.""" + if repository_ctx.os.environ.get("TF_NEED_XPU", "0") != "1": + return False + oneapi_root = repository_ctx.os.environ.get(_ONEAPI_ROOT, "") + if oneapi_root and repository_ctx.path(oneapi_root).exists: + return True + for path in ["/opt/intel/oneapi", "/opt/oneapi"]: + if repository_ctx.path(path).exists: + return True + auto_configure_fail( + "TF_NEED_XPU=1 but cannot find oneAPI SDK. " + + "Set ONEAPI_ROOT or install to /opt/intel/oneapi.") + +def _get_python_bin(repository_ctx): + """Get the python binary path, or fail with a clear message.""" + python_bin = repository_ctx.os.environ.get(_PYTHON_BIN_PATH, "") + if python_bin: + return python_bin + python_bin = repository_ctx.which("python3") + if python_bin != None: + return str(python_bin) + auto_configure_fail( + "Cannot find python3 in PATH. Please set PYTHON_BIN_PATH " + + "environment variable or ensure python3 is installed.") + +def _get_python_include(repository_ctx, python_bin): + """Get the Python C include directory via sysconfig.""" + result = repository_ctx.execute([ + python_bin, "-c", + "import sysconfig; print(sysconfig.get_path('include'))", + ]) + if result.return_code != 0: + auto_configure_fail("Cannot get Python include path: " + result.stderr) + return result.stdout.strip() + +def _get_python_lib(repository_ctx, python_bin): + """Get the Python shared library path (libpython3.x.so).""" + result = repository_ctx.execute([ + python_bin, "-c", + "import sysconfig, os; d=sysconfig.get_config_var('LIBDIR'); " + + "v=sysconfig.get_config_var('LDVERSION'); " + + "print(os.path.join(d, 'libpython'+v+'.so'))", + ]) + if result.return_code != 0: + auto_configure_fail("Cannot get Python lib path: " + result.stderr) + return result.stdout.strip() + +def _create_dummy_repository(repository_ctx): + """Create a minimal stub repository when XPU SDK is not available.""" + repository_ctx.file("BUILD.bazel", """ +package(default_visibility = ["//visibility:public"]) + +cc_library( + name = "crosstool", +) + +# Stub py_runtime so --python_top=@local_config_xpu//:python_runtime resolves. +py_runtime( + name = "python_runtime", + interpreter_path = "/usr/bin/python3", + python_version = "PY3", + visibility = ["//visibility:public"], +) + +# Stub python_headers/python_lib so @local_config_xpu targets resolve on non-XPU builds. +cc_library(name = "python_headers") +cc_library(name = "python_lib") +""") + repository_ctx.file("crosstool/BUILD", """ +package(default_visibility = ["//visibility:public"]) + +filegroup(name = "empty", srcs = []) + +cc_toolchain_suite( + name = "toolchain", + toolchains = {}, +) +""") + + # Stub xpu/BUILD so @local_config_xpu//xpu: targets resolve on non-XPU builds. + repository_ctx.file("xpu/BUILD", """ +package(default_visibility = ["//visibility:public"]) + +cc_library(name = "xpu_headers") +cc_library(name = "sycl_runtime") +cc_library(name = "ze_loader") +cc_library(name = "xpu") +""") + +def _xpu_configure_impl(repository_ctx): + """Implementation of the xpu_configure repository rule.""" + if not _enable_xpu(repository_ctx): + _create_dummy_repository(repository_ctx) + return + oneapi_root = _oneapi_root(repository_ctx) + icx_path = _find_icx(repository_ctx, oneapi_root) + icpx_path = _find_icpx(repository_ctx, oneapi_root) + + # Resolve symlinks so paths match what the compiler reports to Bazel + icx_path = str(repository_ctx.path(icx_path).realpath) + icpx_path = str(repository_ctx.path(icpx_path).realpath) + oneapi_compiler_dir = str(repository_ctx.path(oneapi_root + "/compiler/latest").realpath) + oneapi_include = oneapi_compiler_dir + "/include" + + # Use icpx as the host compiler for getting include directories + host_compiler_includes = get_cxx_inc_directories(repository_ctx, icpx_path) + if not host_compiler_includes: + auto_configure_fail( + "TF_NEED_XPU=1 but failed to detect include directories from " + + icpx_path + ". Verify icpx is installed and executes correctly.") + + host_compiler_prefix = "/usr/bin" + + # --- Generate the crosstool wrapper script --- + _tpl( + repository_ctx, + "crosstool:clang/bin/crosstool_wrapper_driver_xpu", + { + "%{icx_path}": icx_path, + "%{icpx_path}": icpx_path, + "%{oneapi_include_path}": oneapi_include, + }, + out = "crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc", + ) + + # --- Generate crosstool BUILD and cc_toolchain_config --- + xpu_defines = {} + xpu_defines["%{host_compiler_path}"] = "clang/bin/crosstool_wrapper_driver_is_not_gcc" + xpu_defines["%{host_compiler_prefix}"] = host_compiler_prefix + xpu_defines["%{linker_bin_path}"] = "/usr/bin" + xpu_defines["%{extra_no_canonical_prefixes_flags}"] = "" + xpu_defines["%{unfiltered_compile_flags}"] = to_list_of_strings([ + "-DUSING_XPU=1", + ]) + xpu_defines["%{host_compiler_warnings}"] = to_list_of_strings([ + "-Wno-error", + ]) + xpu_defines["%{cxx_builtin_include_directories}"] = to_list_of_strings( + [str(d) for d in host_compiler_includes] + [oneapi_include], + ) + xpu_defines["%{compiler_deps}"] = "clang/bin/crosstool_wrapper_driver_is_not_gcc" + xpu_defines["%{linker_files}"] = "clang/bin/crosstool_wrapper_driver_is_not_gcc" + xpu_defines["%{win_linker_files}"] = ":empty" + + # Dummy Windows defines (required by verify_build_defines) + xpu_defines["%{msvc_cl_path}"] = "msvc_not_used" + xpu_defines["%{msvc_env_include}"] = "msvc_not_used" + xpu_defines["%{msvc_env_lib}"] = "msvc_not_used" + xpu_defines["%{msvc_env_path}"] = "msvc_not_used" + xpu_defines["%{msvc_env_tmp}"] = "msvc_not_used" + xpu_defines["%{msvc_lib_path}"] = "msvc_not_used" + xpu_defines["%{msvc_link_path}"] = "msvc_not_used" + xpu_defines["%{msvc_ml_path}"] = "msvc_not_used" + + verify_build_defines(xpu_defines) + + _tpl(repository_ctx, "crosstool:BUILD", xpu_defines) + + # Probe for the Level Zero loader BEFORE generating the toolchain config so + # its directory can be handed to the linker as -L (the toolchain links + # -lze_loader unconditionally, and the loader may live in oneAPI's lib dir + # rather than a default linker search path). Fail fast if it is missing. + ze_loader_lib = "" + for path in ["/usr/lib/x86_64-linux-gnu/libze_loader.so", + "/usr/lib64/libze_loader.so", + oneapi_compiler_dir + "/lib/libze_loader.so"]: + if repository_ctx.path(path).exists: + ze_loader_lib = path + break + if not ze_loader_lib: + auto_configure_fail( + "TF_NEED_XPU=1 but libze_loader.so not found. " + + "The XPU toolchain unconditionally links -lze_loader. " + + "Install the Level Zero loader (e.g. level-zero-devel) or " + + "ensure it is in /usr/lib/x86_64-linux-gnu/, /usr/lib64/, " + + "or " + oneapi_compiler_dir + "/lib/.") + ze_loader_lib_dir = ze_loader_lib.rsplit("/", 1)[0] + + # Substitute SYCL target and ze_loader search dir into toolchain config template + sycl_target = _get_sycl_target(repository_ctx) + _tpl( + repository_ctx, + "crosstool:xpu_cc_toolchain_config.bzl", + { + "%{xpu_sycl_target}": sycl_target, + "%{ze_loader_lib_dir}": ze_loader_lib_dir, + }, + out = "crosstool/cc_toolchain_config.bzl", + ) + + # --- Generate xpu/BUILD with SYCL runtime libraries --- + sycl_lib = oneapi_compiler_dir + "/lib/libsycl.so" + + xpu_build_substitutions = {} + if repository_ctx.path(sycl_lib).exists: + repository_ctx.symlink(sycl_lib, "xpu/lib/libsycl.so") + xpu_build_substitutions["%{sycl_runtime_srcs}"] = '["lib/libsycl.so"]' + else: + auto_configure_fail( + ("TF_NEED_XPU=1 but libsycl.so not found at %s. " + + "Is the oneAPI DPC++ compiler installed correctly?") % sycl_lib) + + repository_ctx.symlink(ze_loader_lib, "xpu/lib/libze_loader.so") + xpu_build_substitutions["%{ze_loader_srcs}"] = '["lib/libze_loader.so"]' + + xpu_build_substitutions["%{copy_rules}"] = "" + + # Symlink SYCL headers + sycl_include = oneapi_compiler_dir + "/include" + if repository_ctx.path(sycl_include + "/sycl").exists: + repository_ctx.symlink(sycl_include, "xpu/include") + else: + auto_configure_fail( + ("TF_NEED_XPU=1 but SYCL headers not found at %s/sycl. " + + "Is the oneAPI DPC++ compiler installed correctly?") % sycl_include) + + _tpl(repository_ctx, "xpu:BUILD", xpu_build_substitutions) + + # --- Generate py_runtime so .bazelrc can set --python_top=@local_config_xpu//:python_runtime --- + python_bin = _get_python_bin(repository_ctx) + # Resolve symlinked python to venv python so site-packages is correct + python_bin = resolve_venv_python(repository_ctx, python_bin) + + # Validate Python version: XPU builds require Python 3.12 (PyTorch XPU + # ships only cp312 wheels). In XPU containers /opt/conda310/bin/python3 + # is a symlink to a Python 3.12 venv; fail early if the resolved + # interpreter is something else. + _py_ver = repository_ctx.execute([python_bin, "-c", + "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"]) + if _py_ver.return_code == 0: + _ver = _py_ver.stdout.strip() + if _ver != "3.12": + auto_configure_fail( + "XPU build requires Python 3.12 but PYTHON_BIN_PATH (%s) " % python_bin + + "resolves to Python %s. " % _ver + + "In the XPU Docker image, /opt/conda310/bin/python3 should be a symlink " + + "to a Python 3.12 venv. Check your container setup.") + else: + auto_configure_fail( + "Failed to detect Python version from %s (exit code %d).\n" % (python_bin, _py_ver.return_code) + + "stdout: %s\nstderr: %s" % (_py_ver.stdout.strip(), _py_ver.stderr.strip())) + + python_include = _get_python_include(repository_ctx, python_bin) + python_lib = _get_python_lib(repository_ctx, python_bin) + + # Symlink Python include dir and lib .so into the repo so Bazel glob() can + # use package-relative paths (glob() rejects absolute paths). + if not repository_ctx.path(python_include).exists: + auto_configure_fail( + "Python include directory not found at " + python_include + ". " + + "Install python3-dev / python3-devel or ensure PYTHON_BIN_PATH " + + "points to a Python with development headers.") + repository_ctx.symlink(python_include, "python_include") + if not repository_ctx.path(python_lib).exists: + auto_configure_fail( + "Python shared library not found at " + python_lib + ". " + + "Ensure PYTHON_BIN_PATH points to a Python built with --enable-shared " + + "or install the python3-dev / libpython3-dev package.") + python_lib_basename = repository_ctx.path(python_lib).basename + repository_ctx.symlink(python_lib, "python_lib/" + python_lib_basename) + + repository_ctx.file("BUILD.bazel", content = """ +py_runtime( + name = "python_runtime", + interpreter_path = "{python_bin}", + python_version = "PY3", + stub_shebang = "#!{python_bin}", + visibility = ["//visibility:public"], +) + +# Python headers/lib resolved from the XPU venv python (Python 3.12), +# ensuring C++ targets that link torch_xpu use the same ABI as the runtime. +# Absolute paths are symlinked into the repo as python_include/ and python_lib/ +# because Bazel glob() does not accept absolute paths. +cc_library( + name = "python_headers", + hdrs = glob(["python_include/**/*.h"]), + includes = ["python_include"], + visibility = ["//visibility:public"], +) + +cc_library( + name = "python_lib", + srcs = ["python_lib/{python_lib_basename}"], + visibility = ["//visibility:public"], +) +""".format( + python_bin = python_bin, + python_lib_basename = python_lib_basename, + )) + + # --- Torch XPU site-packages setup --- + result = repository_ctx.execute([ + python_bin, "-c", + "import site; print(site.getsitepackages()[0])", + ]) + if result.return_code == 0: + site_packages = result.stdout.strip() + repository_ctx.file( + "xpu/site_packages.bzl", + 'XPU_SITE_PACKAGES = "%s"\n' % site_packages, + ) + else: + # buildifier: disable=print + print("WARNING: site-packages detection failed for XPU: " + result.stderr) + +xpu_configure = repository_rule( + implementation = _xpu_configure_impl, + environ = [ + "TF_NEED_XPU", + _ONEAPI_ROOT, + _PYTHON_BIN_PATH, + _SYCL_TARGET, + ], + doc = """Configures the Intel XPU (icx/icpx) C/C++ toolchain. + +Add the following to your WORKSPACE: + +```python +xpu_configure(name = "local_config_xpu") +``` +""", +) diff --git a/3rdparty/gpus/xpu_python_utils.bzl b/3rdparty/gpus/xpu_python_utils.bzl new file mode 100644 index 0000000000..c122f733c6 --- /dev/null +++ b/3rdparty/gpus/xpu_python_utils.bzl @@ -0,0 +1,18 @@ +"""Shared Python utilities for XPU repository rules.""" + +def resolve_venv_python(repository_ctx, python_bin): + """Resolve a possibly-symlinked python to the actual venv python. + + When PYTHON_BIN_PATH points to a symlink (e.g. /opt/conda310/bin/python3 -> + /opt/venv/bin/python3), Python doesn't activate the venv because pyvenv.cfg + isn't found relative to the invoked path. This walks the symlink chain to + find the first python whose parent directory contains pyvenv.cfg. + Falls back to the original path if no venv is found. + """ + result = repository_ctx.execute([ + python_bin, "-c", + "import os, sys\npath = sys.executable\nfor _ in range(10):\n if os.path.islink(path):\n t = os.readlink(path)\n if not os.path.isabs(t): t = os.path.join(os.path.dirname(path), t)\n path = os.path.normpath(t)\n p = os.path.dirname(os.path.dirname(path))\n if os.path.isfile(os.path.join(p, 'pyvenv.cfg')):\n print(path); raise SystemExit\n else: break\nprint(sys.executable)", + ]) + if result.return_code == 0 and result.stdout.strip(): + return result.stdout.strip() + return python_bin diff --git a/BUILD b/BUILD index ab77eddc83..7ebaa6bc15 100755 --- a/BUILD +++ b/BUILD @@ -69,6 +69,11 @@ config_setting( values = {"define": "using_cpu=true"}, ) +config_setting( + name = "using_xpu", + values = {"define": "using_xpu=true"}, +) + selects.config_setting_group( name = "using_cuda12_9", match_any = [ diff --git a/BUILD.pytorch b/BUILD.pytorch index a0bf4741de..17d25a8682 100644 --- a/BUILD.pytorch +++ b/BUILD.pytorch @@ -8,6 +8,11 @@ config_setting( values = {"define": "using_rocm=true"}, ) +config_setting( + name = "using_xpu", + values = {"define": "using_xpu=true"}, +) + cc_library( name = "torch", srcs = [ @@ -46,6 +51,10 @@ cc_library( # "torch/lib/libhip*.so*", # "torch/lib/lib*amd*.so*", ]), + "@//:using_xpu": [ + "torch/lib/libtorch_xpu.so", + "torch/lib/libc10_xpu.so", + ], "//conditions:default": [], }), hdrs = glob([ @@ -54,10 +63,16 @@ cc_library( "torch/include/**/*.cuh", "torch/include/**/*.hpp", ], exclude=["torch/include/google/**"]), - deps = [ - "@local_config_python//:python_headers", - "@local_config_python//:python_lib", - ], + deps = select({ + "@//:using_xpu": [ + "@local_config_xpu//:python_headers", + "@local_config_xpu//:python_lib", + ], + "//conditions:default": [ + "@local_config_python//:python_headers", + "@local_config_python//:python_lib", + ], + }), strip_include_prefix = "torch/include", visibility = ["//visibility:public"], ) @@ -67,9 +82,10 @@ cc_library( hdrs = glob([ "torch/include/torch/csrc/api/include/**/*.h", ]), - deps = [ - "@local_config_python//:python_headers", - ], + deps = select({ + "@//:using_xpu": ["@local_config_xpu//:python_headers"], + "//conditions:default": ["@local_config_python//:python_headers"], + }), strip_include_prefix = "torch/include/torch/csrc/api/include", visibility = ["//visibility:public"], ) @@ -103,8 +119,9 @@ cc_library( ], "//conditions:default": [], }), - deps = [ - "@local_config_python//:python_headers", - ], + deps = select({ + "@//:using_xpu": ["@local_config_xpu//:python_headers"], + "//conditions:default": ["@local_config_python//:python_headers"], + }), visibility = ["//visibility:public"], ) diff --git a/WORKSPACE b/WORKSPACE index 0b68fa234d..98479665b8 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -3,6 +3,8 @@ workspace(name = "rtp_llm") load("//3rdparty/cuda_config:cuda_configure.bzl", "cuda_configure") load("//3rdparty/gpus:rocm_configure.bzl", "rocm_configure") load("//3rdparty/py:python_configure.bzl", "python_configure") +load("//3rdparty/gpus:xpu_configure.bzl", "xpu_configure") +load("//3rdparty/gpus:torch_xpu_configure.bzl", "torch_xpu_configure") cuda_configure(name = "local_config_cuda") @@ -10,6 +12,13 @@ rocm_configure(name = "local_config_rocm") python_configure(name = "local_config_python") +xpu_configure(name = "local_config_xpu") + +torch_xpu_configure( + name = "torch_xpu", + build_file = "//:BUILD.pytorch", +) + local_repository( name = "rtp_deps", path = "deps", @@ -57,5 +66,13 @@ pip_cuda12_arm_torch_install_deps() load("@pip_gpu_rocm_torch//:requirements.bzl", pip_gpu_rocm_torch_install_deps = "install_deps") pip_gpu_rocm_torch_install_deps() +# XPU wheel installation is gated on TF_NEED_XPU (set by --config=xpu) via the +# xpu_pip_gate repo declared in pip_deps(). On non-XPU containers and plain +# `bazel sync`, install_deps() is a no-op, so the pip_xpu_torch_* whl_library +# repos are never declared and XPU-only pins (e.g. scikit-learn==1.8.0, which +# Requires-Python>=3.11) are never resolved under Python 3.10. +load("@xpu_pip_gate//:requirements.bzl", pip_xpu_torch_install_deps = "install_deps") +pip_xpu_torch_install_deps() + load("//:def.bzl", "read_release_version") read_release_version(name = "release_version") diff --git a/arch_config/arch_select.bzl b/arch_config/arch_select.bzl index b3a75553e7..f0e3b5ff98 100644 --- a/arch_config/arch_select.bzl +++ b/arch_config/arch_select.bzl @@ -4,27 +4,105 @@ load("@pip_arm_torch//:requirements.bzl", requirement_arm="requirement") load("@pip_gpu_cuda12_torch//:requirements.bzl", requirement_gpu_cuda12="requirement") load("@pip_gpu_cuda12_9_torch//:requirements.bzl", requirement_gpu_cuda12_9="requirement") load("@pip_gpu_rocm_torch//:requirements.bzl", requirement_gpu_rocm="requirement") +load("@xpu_pip_gate//:requirements.bzl", requirement_xpu="requirement") load("@rtp_llm//bazel:defs.bzl", "copy_so") +# Packages not available in XPU pip environment (CUDA/ROCm-only). +# Names are PEP 503 normalized (lowercase, hyphens). See _normalize_pkg(). +_XPU_EXCLUDED_PACKAGES = [ + "pynvml", "cpm-kernels", "xfastertransformer-devel", + "xfastertransformer-devel-icx", "decord", "av", "onnx", "bitsandbytes", + "pyrsmi", "amdsmi", "fast-safetensors", "fastsafetensors", "blobfile", "pyopenssl", + "pyarrow", "pyodps", "matplotlib", + # CUDA/ROCm GPU kernel packages — not available for XPU + "apache-tvm-ffi", "flashinfer-python", "flashinfer-cubin", + "nvidia-cutlass-dsl", "flashinfer-jit-cache", + "fast-hadamard-transform", "flash-mla", "tilelang", + "deep-gemm", "deep-ep", "rtp-kernel", + "flash-attn", "flash-attn-3", "aiter", +] + +# Packages with different names in the XPU pip environment. +_XPU_PACKAGE_REMAP = { + "triton": "triton-xpu", +} + +# Version-pinned packages whose pins in _whl_reqs_static (CUDA/ROCm) differ +# from the versions in requirements_lock_xpu.txt. The XPU wheel must +# advertise the locked versions so `pip install` does not conflict. +_XPU_VERSION_OVERRIDES = { + "fastapi": "fastapi==0.135.1", + "grpcio": "grpcio==1.78.0", + "grpcio-tools": "grpcio-tools==1.78.0", + "protobuf": "protobuf==6.33.6", + "sentencepiece": "sentencepiece==0.2.1", + "setuptools": "setuptools==82.0.1", + "tiktoken": "tiktoken==0.12.0", + "timm": "timm==1.0.26", + "transformers": "transformers==4.57.6", + "uvicorn": "uvicorn==0.42.0", +} + def copy_all_so(): copy_so("@rtp_llm//:th_transformer") copy_so("@rtp_llm//:th_transformer_config") copy_so("@rtp_llm//:rtp_compute_ops") +def _normalize_pkg(name): + """Normalize package name per PEP 503 (lowercase, replace [-_.] with -).""" + return name.lower().replace("_", "-").replace(".", "-") + def requirement(names): for name in names: + normalized = _normalize_pkg(name) + if normalized in _XPU_EXCLUDED_PACKAGES: + xpu_dep = [] + elif normalized in _XPU_PACKAGE_REMAP: + xpu_dep = [requirement_xpu(_XPU_PACKAGE_REMAP[normalized])] + else: + xpu_dep = [requirement_xpu(name)] native.py_library( name = name, deps = select({ "@rtp_llm//:cuda_pre_12_9": [requirement_gpu_cuda12(name)], "@rtp_llm//:using_cuda12_9_x86": [requirement_gpu_cuda12_9(name)], "@rtp_llm//:using_rocm": [requirement_gpu_rocm(name)], + "@rtp_llm//:using_xpu": xpu_dep, "@rtp_llm//:using_arm": [requirement_arm(name)], "//conditions:default": [requirement_cpu(name)], }), visibility = ["//visibility:public"], ) +def _strip_req_version(req): + """Extract the bare package name from a PEP 508 requirement string.""" + name = req + for sep in ["==", ">=", "<=", "~=", "!=", ">", "<", "@", "[", " ", ";"]: + idx = name.find(sep) + if idx != -1: + name = name[:idx] + return name.strip() + +def filter_xpu_whl_reqs(reqs): + """Return a select() that strips CUDA/ROCm-only packages from wheel + metadata when building for XPU and applies the XPU package remap, so the + XPU wheel does not declare dependencies unavailable for that platform.""" + xpu_reqs = [] + for req in reqs: + normalized = _normalize_pkg(_strip_req_version(req)) + if normalized in _XPU_EXCLUDED_PACKAGES: + continue + elif normalized in _XPU_VERSION_OVERRIDES: + xpu_reqs.append(_XPU_VERSION_OVERRIDES[normalized]) + elif normalized in _XPU_PACKAGE_REMAP: + xpu_reqs.append(_XPU_PACKAGE_REMAP[normalized]) + else: + xpu_reqs.append(req) + return select({ + "@rtp_llm//:using_xpu": xpu_reqs, + "//conditions:default": reqs, + }) + def cache_store_deps(): native.alias( name = "cache_store_arch_select_impl", @@ -59,6 +137,7 @@ def whl_deps(): return select({ "@rtp_llm//:using_cuda12": ["torch==2.6.0+cu126"], "@rtp_llm//:using_rocm": ["pyrsmi==0.2.0", "amdsmi@https://sinian-metrics-platform.oss-cn-hangzhou.aliyuncs.com/kis%2FAMD%2Famd_smi%2Fali%2Famd_smi.tar", "aiter@https://sinian-metrics-platform.oss-cn-hangzhou.aliyuncs.com/kis/AMD/RTP/aiter-0.1.14rc1.dev41%2Bgc39217100.d20260519-cp310-cp310-linux_x86_64.whl"], + "@rtp_llm//:using_xpu": ["torch==2.10.0+xpu", "torchvision==0.25.0+xpu"], "//conditions:default": ["torch==2.1.2"], }) @@ -67,6 +146,7 @@ def platform_deps(): "@rtp_llm//:using_arm": [], "@rtp_llm//:using_cuda12_arm": [], "@rtp_llm//:using_rocm": ["pyyaml==6.0.2","decord==0.6.0", "av==16.1.0"], + "@rtp_llm//:using_xpu": [], "//conditions:default": ["decord==0.6.0", "av==16.1.0"], }) @@ -77,6 +157,11 @@ def torch_deps(): "@torch_rocm//:torch", "@torch_rocm//:torch_libs", ], + "@rtp_llm//:using_xpu": [ + "@torch_xpu//:torch_api", + "@torch_xpu//:torch", + "@torch_xpu//:torch_libs", + ], "@rtp_llm//:using_arm": [ "@torch_2.3_py310_cpu_aarch64//:torch_api", "@torch_2.3_py310_cpu_aarch64//:torch", @@ -122,6 +207,7 @@ def cuda_register(): native.alias( name = "cuda_register", actual = select({ + "@rtp_llm//:using_xpu": "@rtp_llm//rtp_llm:empty_target", "//conditions:default": "@rtp_llm//rtp_llm/models_py/bindings/cuda/ops:gpu_register", }), visibility = ["//visibility:public"], @@ -146,6 +232,9 @@ def select_py_bindings(): "@rtp_llm//:using_rocm": [ "@rtp_llm//rtp_llm/models_py/bindings/rocm:rocm_bindings_register" ], + "@rtp_llm//:using_xpu": [ + "@rtp_llm//rtp_llm/models_py/bindings/xpu:xpu_bindings_register", + ], "//conditions:default": [ "@rtp_llm//rtp_llm/models_py/bindings:dummy_register", ], @@ -160,6 +249,9 @@ def no_block_copy_link_deps(): "@rtp_llm//:using_rocm": [ "@rtp_llm//rtp_llm/models_py/bindings:no_block_copy_default", ], + "@rtp_llm//:using_xpu": [ + "@rtp_llm//rtp_llm/models_py/bindings:no_block_copy_default", + ], "//conditions:default": [ "@rtp_llm//rtp_llm/models_py/bindings:no_block_copy_default", ], diff --git a/bazel/defs.bzl b/bazel/defs.bzl index 541d3eb9c1..8658646325 100644 --- a/bazel/defs.bzl +++ b/bazel/defs.bzl @@ -127,11 +127,11 @@ def pyc_wheel(name, package_name, src): visibility = ["//visibility:public"], ) -def rename_wheel(name, package_name, src): +def rename_wheel(name, package_name, src, python_tag = "cp310"): native.genrule( name = name, srcs = [src], - outs = [package_name + "-cp310-cp310-manylinux1_x86_64.whl"], + outs = [package_name + "-%s-%s-manylinux1_x86_64.whl" % (python_tag, python_tag)], cmd = "bash -c 'set -xe;" + "cp $(locations %s) $(OUTS);" % (src) + "chmod a+w $(OUTS);" + diff --git a/bazel/device_defs.bzl b/bazel/device_defs.bzl index ced49c2abe..b91a1b212b 100644 --- a/bazel/device_defs.bzl +++ b/bazel/device_defs.bzl @@ -10,6 +10,9 @@ def device_test_envs(): "@//:using_rocm": { "TEST_USING_DEVICE": "ROCM", }, + "@//:using_xpu": { + "TEST_USING_DEVICE": "XPU", + }, "//conditions:default": { "TEST_USING_DEVICE": "CUDA", "LD_PRELOAD": "libtorch_cpu.so", diff --git a/deps/BUILD b/deps/BUILD index 7860d9925b..5316554f70 100644 --- a/deps/BUILD +++ b/deps/BUILD @@ -79,3 +79,11 @@ compile_pip_requirements( requirements_txt = "requirements_lock_rocm.txt", tags = ["manual"], ) + +compile_pip_requirements( + name = "requirements_xpu", + src = "requirements_xpu.txt", + extra_args = PIP_EXTRA_ARGS + ["--extra-index-url=https://download.pytorch.org/whl/xpu"], + requirements_txt = "requirements_lock_xpu.txt", + tags = ["manual"], +) diff --git a/deps/pip.bzl b/deps/pip.bzl index 9f0c1b6c93..41e9849587 100644 --- a/deps/pip.bzl +++ b/deps/pip.bzl @@ -65,3 +65,60 @@ def pip_deps(): extra_pip_args = PIP_EXTRA_ARGS, timeout = 12000, ) + + # XPU lockfile was generated with Python 3.12 (PyTorch XPU requires ==3.12). + # pip_parse only declares the hub repo and parses the hashed lockfile; it + # does not download wheels, so declaring it in every container is cheap. + # The actual whl_library fetches DO run the interpreter and would fail on a + # Python 3.10 container (e.g. scikit-learn==1.8.0 is an XPU-only transitive + # pin that Requires-Python>=3.11). Those fetches are gated by xpu_pip_gate + # below on TF_NEED_XPU, so `bazel sync` / non-XPU builds never resolve the + # XPU wheels. + pip_parse( + name = "pip_xpu_torch", + requirements_lock = "@rtp_deps//:requirements_lock_xpu.txt", + python_interpreter = "/opt/conda310/bin/python3", + extra_pip_args = PIP_EXTRA_ARGS + ["--extra-index-url=https://download.pytorch.org/whl/xpu"], + timeout = 3600, + ) + + # Gate XPU wheel installation on TF_NEED_XPU (set by --config=xpu, see + # .bazelrc). Without this, `bazel sync` on a non-XPU Python 3.10 container + # eagerly fetches every pip_xpu_torch_* whl_library and fails to resolve + # XPU-only pins (e.g. scikit-learn==1.8.0, Requires-Python>=3.11). + _xpu_pip_gate(name = "xpu_pip_gate") + + +def _xpu_pip_gate_impl(repository_ctx): + # When building for XPU (--config=xpu sets TF_NEED_XPU=1) re-export the real + # install_deps and requirement from @pip_xpu_torch so the XPU wheels are + # declared/fetched. Otherwise expose no-ops so non-XPU builds and + # `bazel sync` never trigger the pip_xpu_torch repo rule (which contacts + # download.pytorch.org and would fail on internal networks). + enabled = repository_ctx.os.environ.get("TF_NEED_XPU", "0") == "1" + repository_ctx.file("BUILD.bazel", """ +py_library(name = "dummy_pkg", visibility = ["//visibility:public"]) +""") + if enabled: + repository_ctx.file( + "requirements.bzl", + "load(\"@pip_xpu_torch//:requirements.bzl\", _install_deps = \"install_deps\", _requirement = \"requirement\")\n" + + "def install_deps(**kwargs):\n" + + " _install_deps(**kwargs)\n" + + "def requirement(name):\n" + + " return _requirement(name)\n", + ) + else: + repository_ctx.file( + "requirements.bzl", + "def install_deps(**kwargs):\n" + + " pass\n" + + "def requirement(name):\n" + + " return \"@xpu_pip_gate//:dummy_pkg\"\n", + ) + +_xpu_pip_gate = repository_rule( + implementation = _xpu_pip_gate_impl, + environ = ["TF_NEED_XPU"], + configure = True, +) diff --git a/deps/requirements_lock_xpu.txt b/deps/requirements_lock_xpu.txt new file mode 100644 index 0000000000..8dca53f279 --- /dev/null +++ b/deps/requirements_lock_xpu.txt @@ -0,0 +1,3217 @@ +# +# This file is autogenerated by pip-compile with Python 3.12 +# by the following command: +# +# pip-compile --allow-unsafe --extra-index-url=https://download.pytorch.org/whl/xpu --generate-hashes --output-file=deps/requirements_lock_xpu.txt deps/requirements_xpu.txt +# +--extra-index-url https://download.pytorch.org/whl/xpu + +aiohappyeyeballs==2.6.1 \ + --hash=sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558 \ + --hash=sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8 + # via aiohttp +aiohttp==3.13.3 \ + --hash=sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf \ + --hash=sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c \ + --hash=sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c \ + --hash=sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423 \ + --hash=sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f \ + --hash=sha256:0db318f7a6f065d84cb1e02662c526294450b314a02bd9e2a8e67f0d8564ce40 \ + --hash=sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2 \ + --hash=sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf \ + --hash=sha256:147e422fd1223005c22b4fe080f5d93ced44460f5f9c105406b753612b587821 \ + --hash=sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64 \ + --hash=sha256:215a685b6fbbfcf71dfe96e3eba7a6f58f10da1dfdf4889c7dd856abe430dca7 \ + --hash=sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998 \ + --hash=sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d \ + --hash=sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea \ + --hash=sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463 \ + --hash=sha256:2ba0eea45eb5cc3172dbfc497c066f19c41bac70963ea1a67d51fc92e4cf9a80 \ + --hash=sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4 \ + --hash=sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767 \ + --hash=sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43 \ + --hash=sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592 \ + --hash=sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a \ + --hash=sha256:31a83ea4aead760dfcb6962efb1d861db48c34379f2ff72db9ddddd4cda9ea2e \ + --hash=sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687 \ + --hash=sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8 \ + --hash=sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261 \ + --hash=sha256:37da61e244d1749798c151421602884db5270faf479cf0ef03af0ff68954c9dd \ + --hash=sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a \ + --hash=sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4 \ + --hash=sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587 \ + --hash=sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91 \ + --hash=sha256:40c5e40ecc29ba010656c18052b877a1c28f84344825efa106705e835c28530f \ + --hash=sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3 \ + --hash=sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344 \ + --hash=sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6 \ + --hash=sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3 \ + --hash=sha256:4ae5b5a0e1926e504c81c5b84353e7a5516d8778fbbff00429fe7b05bb25cbce \ + --hash=sha256:4e239d501f73d6db1522599e14b9b321a7e3b1de66ce33d53a765d975e9f4808 \ + --hash=sha256:56339a36b9f1fc708260c76c87e593e2afb30d26de9ae1eb445b5e051b98a7a1 \ + --hash=sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29 \ + --hash=sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3 \ + --hash=sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b \ + --hash=sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51 \ + --hash=sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c \ + --hash=sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926 \ + --hash=sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64 \ + --hash=sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f \ + --hash=sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b \ + --hash=sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e \ + --hash=sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440 \ + --hash=sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6 \ + --hash=sha256:69c56fbc1993fa17043e24a546959c0178fe2b5782405ad4559e6c13975c15e3 \ + --hash=sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d \ + --hash=sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415 \ + --hash=sha256:75ca857eba4e20ce9f546cd59c7007b33906a4cd48f2ff6ccf1ccfc3b646f279 \ + --hash=sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce \ + --hash=sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603 \ + --hash=sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0 \ + --hash=sha256:7e63f210bc1b57ef699035f2b4b6d9ce096b5914414a49b0997c839b2bd2223c \ + --hash=sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf \ + --hash=sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591 \ + --hash=sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540 \ + --hash=sha256:81e97251d9298386c2b7dbeb490d3d1badbdc69107fb8c9299dd04eb39bddc0e \ + --hash=sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26 \ + --hash=sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a \ + --hash=sha256:859bd3f2156e81dd01432f5849fc73e2243d4a487c4fd26609b1299534ee1845 \ + --hash=sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a \ + --hash=sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9 \ + --hash=sha256:8a60e60746623925eab7d25823329941aee7242d559baa119ca2b253c88a7bd6 \ + --hash=sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba \ + --hash=sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df \ + --hash=sha256:947c26539750deeaee933b000fb6517cc770bbd064bad6033f1cff4803881e43 \ + --hash=sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679 \ + --hash=sha256:988a8c5e317544fdf0d39871559e67b6341065b87fceac641108c2096d5506b7 \ + --hash=sha256:9a9dc347e5a3dc7dfdbc1f82da0ef29e388ddb2ed281bfce9dd8248a313e62b7 \ + --hash=sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc \ + --hash=sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29 \ + --hash=sha256:9b174f267b5cfb9a7dba9ee6859cecd234e9a681841eb85068059bc867fb8f02 \ + --hash=sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984 \ + --hash=sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1 \ + --hash=sha256:9ebf57d09e131f5323464bd347135a88622d1c0976e88ce15b670e7ad57e4bd6 \ + --hash=sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632 \ + --hash=sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56 \ + --hash=sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239 \ + --hash=sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168 \ + --hash=sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88 \ + --hash=sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc \ + --hash=sha256:af71fff7bac6bb7508956696dce8f6eec2bbb045eceb40343944b1ae62b5ef11 \ + --hash=sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046 \ + --hash=sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0 \ + --hash=sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3 \ + --hash=sha256:b46020d11d23fe16551466c77823df9cc2f2c1e63cc965daf67fa5eec6ca1877 \ + --hash=sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1 \ + --hash=sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c \ + --hash=sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25 \ + --hash=sha256:b99281b0704c103d4e11e72a76f1b543d4946fea7dd10767e7e1b5f00d4e5704 \ + --hash=sha256:bae5c2ed2eae26cc382020edad80d01f36cb8e746da40b292e68fec40421dc6a \ + --hash=sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033 \ + --hash=sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1 \ + --hash=sha256:bfc1cc2fe31a6026a8a88e4ecfb98d7f6b1fec150cfd708adbfd1d2f42257c29 \ + --hash=sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d \ + --hash=sha256:c048058117fd649334d81b4b526e94bde3ccaddb20463a815ced6ecbb7d11160 \ + --hash=sha256:c0e2d366af265797506f0283487223146af57815b388623f0357ef7eac9b209d \ + --hash=sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f \ + --hash=sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f \ + --hash=sha256:c6b8568a3bb5819a0ad087f16d40e5a3fb6099f39ea1d5625a3edc1e923fc538 \ + --hash=sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29 \ + --hash=sha256:d5a372fd5afd301b3a89582817fdcdb6c34124787c70dbcc616f259013e7eef7 \ + --hash=sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72 \ + --hash=sha256:dca68018bf48c251ba17c72ed479f4dafe9dbd5a73707ad8d28a38d11f3d42af \ + --hash=sha256:de2c184bb1fe2cbd2cefba613e9db29a5ab559323f994b6737e370d3da0ac455 \ + --hash=sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57 \ + --hash=sha256:e50a2e1404f063427c9d027378472316201a2290959a295169bcf25992d04558 \ + --hash=sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c \ + --hash=sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808 \ + --hash=sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7 \ + --hash=sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0 \ + --hash=sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3 \ + --hash=sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730 \ + --hash=sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa \ + --hash=sha256:fee0c6bc7db1de362252affec009707a17478a00ec69f797d23ca256e36d5940 + # via + # -r deps/requirements_xpu.txt + # dashscope +aiosignal==1.4.0 \ + --hash=sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e \ + --hash=sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7 + # via aiohttp +aliyun-python-sdk-core==2.16.0 \ + --hash=sha256:651caad597eb39d4fad6cf85133dffe92837d53bdf62db9d8f37dab6508bb8f9 + # via + # aliyun-python-sdk-kms + # oss2 +aliyun-python-sdk-kms==2.16.5 \ + --hash=sha256:24b6cdc4fd161d2942619479c8d050c63ea9cd22b044fe33b60bbb60153786f0 \ + --hash=sha256:f328a8a19d83ecbb965ffce0ec1e9930755216d104638cd95ecd362753b813b3 + # via oss2 +annotated-doc==0.0.4 \ + --hash=sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320 \ + --hash=sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4 + # via fastapi +annotated-types==0.7.0 \ + --hash=sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53 \ + --hash=sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89 + # via pydantic +anyio==4.12.1 \ + --hash=sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703 \ + --hash=sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c + # via + # httpx + # openai + # starlette +attrs==26.1.0 \ + --hash=sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 \ + --hash=sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32 + # via aiohttp +audioread==3.1.0 \ + --hash=sha256:1c4ab2f2972764c896a8ac61ac53e261c8d29f0c6ccd652f84e18f08a4cab190 \ + --hash=sha256:b30d1df6c5d3de5dcef0fb0e256f6ea17bdcf5f979408df0297d8a408e2971b4 + # via librosa +certifi==2026.2.25 \ + --hash=sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa \ + --hash=sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7 + # via + # dashscope + # httpcore + # httpx + # requests +cffi==2.0.0 \ + --hash=sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb \ + --hash=sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b \ + --hash=sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f \ + --hash=sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9 \ + --hash=sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44 \ + --hash=sha256:0f6084a0ea23d05d20c3edcda20c3d006f9b6f3fefeac38f59262e10cef47ee2 \ + --hash=sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c \ + --hash=sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75 \ + --hash=sha256:1cd13c99ce269b3ed80b417dcd591415d3372bcac067009b6e0f59c7d4015e65 \ + --hash=sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e \ + --hash=sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a \ + --hash=sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e \ + --hash=sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25 \ + --hash=sha256:2081580ebb843f759b9f617314a24ed5738c51d2aee65d31e02f6f7a2b97707a \ + --hash=sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe \ + --hash=sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b \ + --hash=sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91 \ + --hash=sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592 \ + --hash=sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187 \ + --hash=sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c \ + --hash=sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1 \ + --hash=sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94 \ + --hash=sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba \ + --hash=sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb \ + --hash=sha256:3f4d46d8b35698056ec29bca21546e1551a205058ae1a181d871e278b0b28165 \ + --hash=sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529 \ + --hash=sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca \ + --hash=sha256:4647afc2f90d1ddd33441e5b0e85b16b12ddec4fca55f0d9671fef036ecca27c \ + --hash=sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6 \ + --hash=sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c \ + --hash=sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0 \ + --hash=sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743 \ + --hash=sha256:61d028e90346df14fedc3d1e5441df818d095f3b87d286825dfcbd6459b7ef63 \ + --hash=sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5 \ + --hash=sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5 \ + --hash=sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4 \ + --hash=sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d \ + --hash=sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b \ + --hash=sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93 \ + --hash=sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205 \ + --hash=sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27 \ + --hash=sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512 \ + --hash=sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d \ + --hash=sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c \ + --hash=sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037 \ + --hash=sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26 \ + --hash=sha256:89472c9762729b5ae1ad974b777416bfda4ac5642423fa93bd57a09204712322 \ + --hash=sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb \ + --hash=sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c \ + --hash=sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8 \ + --hash=sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4 \ + --hash=sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414 \ + --hash=sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9 \ + --hash=sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664 \ + --hash=sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9 \ + --hash=sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775 \ + --hash=sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739 \ + --hash=sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc \ + --hash=sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062 \ + --hash=sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe \ + --hash=sha256:b882b3df248017dba09d6b16defe9b5c407fe32fc7c65a9c69798e6175601be9 \ + --hash=sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92 \ + --hash=sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5 \ + --hash=sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13 \ + --hash=sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d \ + --hash=sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26 \ + --hash=sha256:cb527a79772e5ef98fb1d700678fe031e353e765d1ca2d409c92263c6d43e09f \ + --hash=sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495 \ + --hash=sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b \ + --hash=sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6 \ + --hash=sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c \ + --hash=sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef \ + --hash=sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5 \ + --hash=sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18 \ + --hash=sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad \ + --hash=sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3 \ + --hash=sha256:de8dad4425a6ca6e4e5e297b27b5c824ecc7581910bf9aee86cb6835e6812aa7 \ + --hash=sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5 \ + --hash=sha256:e6e73b9e02893c764e7e8d5bb5ce277f1a009cd5243f8228f75f842bf937c534 \ + --hash=sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49 \ + --hash=sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2 \ + --hash=sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5 \ + --hash=sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453 \ + --hash=sha256:fe562eb1a64e67dd297ccc4f5addea2501664954f2692b69a76449ec7913ecbf + # via + # cryptography + # soundfile +charset-normalizer==3.4.6 \ + --hash=sha256:06a7e86163334edfc5d20fe104db92fcd666e5a5df0977cb5680a506fe26cc8e \ + --hash=sha256:0c173ce3a681f309f31b87125fecec7a5d1347261ea11ebbb856fa6006b23c8c \ + --hash=sha256:0e28d62a8fc7a1fa411c43bd65e346f3bce9716dc51b897fbe930c5987b402d5 \ + --hash=sha256:0e901eb1049fdb80f5bd11ed5ea1e498ec423102f7a9b9e4645d5b8204ff2815 \ + --hash=sha256:11afb56037cbc4b1555a34dd69151e8e069bee82e613a73bef6e714ce733585f \ + --hash=sha256:150b8ce8e830eb7ccb029ec9ca36022f756986aaaa7956aad6d9ec90089338c0 \ + --hash=sha256:172985e4ff804a7ad08eebec0a1640ece87ba5041d565fff23c8f99c1f389484 \ + --hash=sha256:197c1a244a274bb016dd8b79204850144ef77fe81c5b797dc389327adb552407 \ + --hash=sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6 \ + --hash=sha256:1cf0a70018692f85172348fe06d3a4b63f94ecb055e13a00c644d368eb82e5b8 \ + --hash=sha256:1ed80ff870ca6de33f4d953fda4d55654b9a2b340ff39ab32fa3adbcd718f264 \ + --hash=sha256:22c6f0c2fbc31e76c3b8a86fba1a56eda6166e238c29cdd3d14befdb4a4e4815 \ + --hash=sha256:231d4da14bcd9301310faf492051bee27df11f2bc7549bc0bb41fef11b82daa2 \ + --hash=sha256:259695e2ccc253feb2a016303543d691825e920917e31f894ca1a687982b1de4 \ + --hash=sha256:2a24157fa36980478dd1770b585c0f30d19e18f4fb0c47c13aa568f871718579 \ + --hash=sha256:2b1a63e8224e401cafe7739f77efd3f9e7f5f2026bda4aead8e59afab537784f \ + --hash=sha256:2bd9d128ef93637a5d7a6af25363cf5dec3fa21cf80e68055aad627f280e8afa \ + --hash=sha256:2e1d8ca8611099001949d1cdfaefc510cf0f212484fe7c565f735b68c78c3c95 \ + --hash=sha256:2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab \ + --hash=sha256:2f7fdd9b6e6c529d6a2501a2d36b240109e78a8ceaef5687cfcfa2bbe671d297 \ + --hash=sha256:30f445ae60aad5e1f8bdbb3108e39f6fbc09f4ea16c815c66578878325f8f15a \ + --hash=sha256:31215157227939b4fb3d740cd23fe27be0439afef67b785a1eb78a3ae69cba9e \ + --hash=sha256:34315ff4fc374b285ad7f4a0bf7dcbfe769e1b104230d40f49f700d4ab6bbd84 \ + --hash=sha256:3516bbb8d42169de9e61b8520cbeeeb716f12f4ecfe3fd30a9919aa16c806ca8 \ + --hash=sha256:3778fd7d7cd04ae8f54651f4a7a0bd6e39a0cf20f801720a4c21d80e9b7ad6b0 \ + --hash=sha256:39f5068d35621da2881271e5c3205125cc456f54e9030d3f723288c873a71bf9 \ + --hash=sha256:404a1e552cf5b675a87f0651f8b79f5f1e6fd100ee88dc612f89aa16abd4486f \ + --hash=sha256:419a9d91bd238052642a51938af8ac05da5b3343becde08d5cdeab9046df9ee1 \ + --hash=sha256:423fb7e748a08f854a08a222b983f4df1912b1daedce51a72bd24fe8f26a1843 \ + --hash=sha256:4482481cb0572180b6fd976a4d5c72a30263e98564da68b86ec91f0fe35e8565 \ + --hash=sha256:461598cd852bfa5a61b09cae2b1c02e2efcd166ee5516e243d540ac24bfa68a7 \ + --hash=sha256:47955475ac79cc504ef2704b192364e51d0d473ad452caedd0002605f780101c \ + --hash=sha256:48696db7f18afb80a068821504296eb0787d9ce239b91ca15059d1d3eaacf13b \ + --hash=sha256:4be9f4830ba8741527693848403e2c457c16e499100963ec711b1c6f2049b7c7 \ + --hash=sha256:4d1d02209e06550bdaef34af58e041ad71b88e624f5d825519da3a3308e22687 \ + --hash=sha256:4f41da960b196ea355357285ad1316a00099f22d0929fe168343b99b254729c9 \ + --hash=sha256:517ad0e93394ac532745129ceabdf2696b609ec9f87863d337140317ebce1c14 \ + --hash=sha256:51fb3c322c81d20567019778cb5a4a6f2dc1c200b886bc0d636238e364848c89 \ + --hash=sha256:5273b9f0b5835ff0350c0828faea623c68bfa65b792720c453e22b25cc72930f \ + --hash=sha256:530d548084c4a9f7a16ed4a294d459b4f229db50df689bfe92027452452943a0 \ + --hash=sha256:530e8cebeea0d76bdcf93357aa5e41336f48c3dc709ac52da2bb167c5b8271d9 \ + --hash=sha256:54fae94be3d75f3e573c9a1b5402dc593de19377013c9a0e4285e3d402dd3a2a \ + --hash=sha256:572d7c822caf521f0525ba1bce1a622a0b85cf47ffbdae6c9c19e3b5ac3c4389 \ + --hash=sha256:58c948d0d086229efc484fe2f30c2d382c86720f55cd9bc33591774348ad44e0 \ + --hash=sha256:5d11595abf8dd942a77883a39d81433739b287b6aa71620f15164f8096221b30 \ + --hash=sha256:5f8ddd609f9e1af8c7bd6e2aca279c931aefecd148a14402d4e368f3171769fd \ + --hash=sha256:5feb91325bbceade6afab43eb3b508c63ee53579fe896c77137ded51c6b6958e \ + --hash=sha256:60c74963d8350241a79cb8feea80e54d518f72c26db618862a8f53e5023deaf9 \ + --hash=sha256:613f19aa6e082cf96e17e3ffd89383343d0d589abda756b7764cf78361fd41dc \ + --hash=sha256:659a1e1b500fac8f2779dd9e1570464e012f43e580371470b45277a27baa7532 \ + --hash=sha256:695f5c2823691a25f17bc5d5ffe79fa90972cc34b002ac6c843bb8a1720e950d \ + --hash=sha256:69dd852c2f0ad631b8b60cfbe25a28c0058a894de5abb566619c205ce0550eae \ + --hash=sha256:6cceb5473417d28edd20c6c984ab6fee6c6267d38d906823ebfe20b03d607dc2 \ + --hash=sha256:71be7e0e01753a89cf024abf7ecb6bca2c81738ead80d43004d9b5e3f1244e64 \ + --hash=sha256:74119174722c4349af9708993118581686f343adc1c8c9c007d59be90d077f3f \ + --hash=sha256:74a2e659c7ecbc73562e2a15e05039f1e22c75b7c7618b4b574a3ea9118d1557 \ + --hash=sha256:7504e9b7dc05f99a9bbb4525c67a2c155073b44d720470a148b34166a69c054e \ + --hash=sha256:79090741d842f564b1b2827c0b82d846405b744d31e84f18d7a7b41c20e473ff \ + --hash=sha256:7a6967aaf043bceabab5412ed6bd6bd26603dae84d5cb75bf8d9a74a4959d398 \ + --hash=sha256:7bda6eebafd42133efdca535b04ccb338ab29467b3f7bf79569883676fc628db \ + --hash=sha256:7edbed096e4a4798710ed6bc75dcaa2a21b68b6c356553ac4823c3658d53743a \ + --hash=sha256:7f9019c9cb613f084481bd6a100b12e1547cf2efe362d873c2e31e4035a6fa43 \ + --hash=sha256:802168e03fba8bbc5ce0d866d589e4b1ca751d06edee69f7f3a19c5a9fe6b597 \ + --hash=sha256:80d0a5615143c0b3225e5e3ef22c8d5d51f3f72ce0ea6fb84c943546c7b25b6c \ + --hash=sha256:82060f995ab5003a2d6e0f4ad29065b7672b6593c8c63559beefe5b443242c3e \ + --hash=sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2 \ + --hash=sha256:8761ac29b6c81574724322a554605608a9960769ea83d2c73e396f3df896ad54 \ + --hash=sha256:87725cfb1a4f1f8c2fc9890ae2f42094120f4b44db9360be5d99a4c6b0e03a9e \ + --hash=sha256:899d28f422116b08be5118ef350c292b36fc15ec2daeb9ea987c89281c7bb5c4 \ + --hash=sha256:8bc5f0687d796c05b1e28ab0d38a50e6309906ee09375dd3aff6a9c09dd6e8f4 \ + --hash=sha256:8bea55c4eef25b0b19a0337dc4e3f9a15b00d569c77211fa8cde38684f234fb7 \ + --hash=sha256:8e5a94886bedca0f9b78fecd6afb6629142fd2605aa70a125d49f4edc6037ee6 \ + --hash=sha256:90ca27cd8da8118b18a52d5f547859cc1f8354a00cd1e8e5120df3e30d6279e5 \ + --hash=sha256:92734d4d8d187a354a556626c221cd1a892a4e0802ccb2af432a1d85ec012194 \ + --hash=sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69 \ + --hash=sha256:95b52c68d64c1878818687a473a10547b3292e82b6f6fe483808fb1468e2f52f \ + --hash=sha256:97d0235baafca5f2b09cf332cc275f021e694e8362c6bb9c96fc9a0eb74fc316 \ + --hash=sha256:9ca4c0b502ab399ef89248a2c84c54954f77a070f28e546a85e91da627d1301e \ + --hash=sha256:9cc4fc6c196d6a8b76629a70ddfcd4635a6898756e2d9cac5565cf0654605d73 \ + --hash=sha256:9cc6e6d9e571d2f863fa77700701dae73ed5f78881efc8b3f9a4398772ff53e8 \ + --hash=sha256:a056d1ad2633548ca18ffa2f85c202cfb48b68615129143915b8dc72a806a923 \ + --hash=sha256:a26611d9987b230566f24a0a125f17fe0de6a6aff9f25c9f564aaa2721a5fb88 \ + --hash=sha256:a4474d924a47185a06411e0064b803c68be044be2d60e50e8bddcc2649957c1f \ + --hash=sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21 \ + --hash=sha256:a9e68c9d88823b274cf1e72f28cb5dc89c990edf430b0bfd3e2fb0785bfeabf4 \ + --hash=sha256:aa9cccf4a44b9b62d8ba8b4dd06c649ba683e4bf04eea606d2e94cfc2d6ff4d6 \ + --hash=sha256:ab30e5e3e706e3063bc6de96b118688cb10396b70bb9864a430f67df98c61ecc \ + --hash=sha256:ac2393c73378fea4e52aa56285a3d64be50f1a12395afef9cce47772f60334c2 \ + --hash=sha256:ad8faf8df23f0378c6d527d8b0b15ea4a2e23c89376877c598c4870d1b2c7866 \ + --hash=sha256:b35b200d6a71b9839a46b9b7fff66b6638bb52fc9658aa58796b0326595d3021 \ + --hash=sha256:b3694e3f87f8ac7ce279d4355645b3c878d24d1424581b46282f24b92f5a4ae2 \ + --hash=sha256:b4ff1d35e8c5bd078be89349b6f3a845128e685e751b6ea1169cf2160b344c4d \ + --hash=sha256:bbc8c8650c6e51041ad1be191742b8b421d05bbd3410f43fa2a00c8db87678e8 \ + --hash=sha256:bc72863f4d9aba2e8fd9085e63548a324ba706d2ea2c83b260da08a59b9482de \ + --hash=sha256:bf625105bb9eef28a56a943fec8c8a98aeb80e7d7db99bd3c388137e6eb2d237 \ + --hash=sha256:c2274ca724536f173122f36c98ce188fd24ce3dad886ec2b7af859518ce008a4 \ + --hash=sha256:c45a03a4c69820a399f1dda9e1d8fbf3562eda46e7720458180302021b08f778 \ + --hash=sha256:c8ae56368f8cc97c7e40a7ee18e1cedaf8e780cd8bc5ed5ac8b81f238614facb \ + --hash=sha256:c907cdc8109f6c619e6254212e794d6548373cc40e1ec75e6e3823d9135d29cc \ + --hash=sha256:ca0276464d148c72defa8bb4390cce01b4a0e425f3b50d1435aa6d7a18107602 \ + --hash=sha256:cd5e2801c89992ed8c0a3f0293ae83c159a60d9a5d685005383ef4caca77f2c4 \ + --hash=sha256:d08ec48f0a1c48d75d0356cea971921848fb620fdeba805b28f937e90691209f \ + --hash=sha256:d1a2ee9c1499fc8f86f4521f27a973c914b211ffa87322f4ee33bb35392da2c5 \ + --hash=sha256:d5f5d1e9def3405f60e3ca8232d56f35c98fb7bf581efcc60051ebf53cb8b611 \ + --hash=sha256:d60377dce4511655582e300dc1e5a5f24ba0cb229005a1d5c8d0cb72bb758ab8 \ + --hash=sha256:d73beaac5e90173ac3deb9928a74763a6d230f494e4bfb422c217a0ad8e629bf \ + --hash=sha256:d7de2637729c67d67cf87614b566626057e95c303bc0a55ffe391f5205e7003d \ + --hash=sha256:dad6e0f2e481fffdcf776d10ebee25e0ef89f16d691f1e5dee4b586375fdc64b \ + --hash=sha256:dda86aba335c902b6149a02a55b38e96287157e609200811837678214ba2b1db \ + --hash=sha256:df01808ee470038c3f8dc4f48620df7225c49c2d6639e38f96e6d6ac6e6f7b0e \ + --hash=sha256:e1f6e2f00a6b8edb562826e4632e26d063ac10307e80f7461f7de3ad8ef3f077 \ + --hash=sha256:e25369dc110d58ddf29b949377a93e0716d72a24f62bad72b2b39f155949c1fd \ + --hash=sha256:e3c701e954abf6fc03a49f7c579cc80c2c6cc52525340ca3186c41d3f33482ef \ + --hash=sha256:e5bcc1a1ae744e0bb59641171ae53743760130600da8db48cbb6e4918e186e4e \ + --hash=sha256:e68c14b04827dd76dcbd1aeea9e604e3e4b78322d8faf2f8132c7138efa340a8 \ + --hash=sha256:e8aeb10fcbe92767f0fa69ad5a72deca50d0dca07fbde97848997d778a50c9fe \ + --hash=sha256:e985a16ff513596f217cee86c21371b8cd011c0f6f056d0920aa2d926c544058 \ + --hash=sha256:ecbbd45615a6885fe3240eb9db73b9e62518b611850fdf8ab08bd56de7ad2b17 \ + --hash=sha256:ee4ec14bc1680d6b0afab9aea2ef27e26d2024f18b24a2d7155a52b60da7e833 \ + --hash=sha256:ef5960d965e67165d75b7c7ffc60a83ec5abfc5c11b764ec13ea54fbef8b4421 \ + --hash=sha256:f0cdaecd4c953bfae0b6bb64910aaaca5a424ad9c72d85cb88417bb9814f7550 \ + --hash=sha256:f1ce721c8a7dfec21fcbdfe04e8f68174183cf4e8188e0645e92aa23985c57ff \ + --hash=sha256:f50498891691e0864dc3da965f340fada0771f6142a378083dc4608f4ea513e2 \ + --hash=sha256:f5ea69428fa1b49573eef0cc44a1d43bebd45ad0c611eb7d7eac760c7ae771bc \ + --hash=sha256:f61aa92e4aad0be58eb6eb4e0c21acf32cf8065f4b2cae5665da756c4ceef982 \ + --hash=sha256:f6e4333fb15c83f7d1482a76d45a0818897b3d33f00efd215528ff7c51b8e35d \ + --hash=sha256:f820f24b09e3e779fe84c3c456cb4108a7aa639b0d1f02c28046e11bfcd088ed \ + --hash=sha256:f98059e4fcd3e3e4e2d632b7cf81c2faae96c43c60b569e9c621468082f1d104 \ + --hash=sha256:fcce033e4021347d80ed9c66dcf1e7b1546319834b74445f561d2e2221de5659 + # via requests +click==8.3.1 \ + --hash=sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a \ + --hash=sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6 + # via uvicorn +concurrent-log-handler==0.9.29 \ + --hash=sha256:0d6c077fbaef2dae49a25975dcf72a602fe0a6a4ce80a3b7c37696d37e10459a \ + --hash=sha256:bc37a76d3f384cbf4a98f693ebd770543edc0f4cd5c6ab6bc70e9e1d7d582265 + # via -r deps/requirements_xpu.txt +crcmod==1.7 \ + --hash=sha256:dc7051a0db5f2bd48665a990d3ec1cc305a466a77358ca4492826f41f283601e + # via oss2 +cryptography==46.0.5 \ + --hash=sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72 \ + --hash=sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235 \ + --hash=sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9 \ + --hash=sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356 \ + --hash=sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257 \ + --hash=sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad \ + --hash=sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4 \ + --hash=sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c \ + --hash=sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614 \ + --hash=sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed \ + --hash=sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31 \ + --hash=sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229 \ + --hash=sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0 \ + --hash=sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731 \ + --hash=sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b \ + --hash=sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4 \ + --hash=sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4 \ + --hash=sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263 \ + --hash=sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595 \ + --hash=sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1 \ + --hash=sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678 \ + --hash=sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48 \ + --hash=sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76 \ + --hash=sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0 \ + --hash=sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18 \ + --hash=sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d \ + --hash=sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d \ + --hash=sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1 \ + --hash=sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981 \ + --hash=sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7 \ + --hash=sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82 \ + --hash=sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2 \ + --hash=sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4 \ + --hash=sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663 \ + --hash=sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c \ + --hash=sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d \ + --hash=sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a \ + --hash=sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a \ + --hash=sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d \ + --hash=sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b \ + --hash=sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a \ + --hash=sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826 \ + --hash=sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee \ + --hash=sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9 \ + --hash=sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648 \ + --hash=sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da \ + --hash=sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2 \ + --hash=sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2 \ + --hash=sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87 + # via + # aliyun-python-sdk-core + # dashscope +dacite==1.9.2 \ + --hash=sha256:053f7c3f5128ca2e9aceb66892b1a3c8936d02c686e707bee96e19deef4bc4a0 \ + --hash=sha256:6ccc3b299727c7aa17582f0021f6ae14d5de47c7227932c47fec4cdfefd26f09 + # via -r deps/requirements_xpu.txt +dashscope==1.25.16 \ + --hash=sha256:85d26bdc5faaaa8ba42a9478e48f4ddf917d670be3400ded60c82f57b931694d + # via -r deps/requirements_xpu.txt +decorator==5.2.1 \ + --hash=sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360 \ + --hash=sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a + # via librosa +distro==1.9.0 \ + --hash=sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed \ + --hash=sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2 + # via openai +dpcpp-cpp-rt==2025.3.1 \ + --hash=sha256:6564f19dc5745c00b49ea74952df13c26c4e23aa20b7292928a30d75e384f986 \ + --hash=sha256:d853f3a0a44432ac03ff0a75ac2f28615773c64d5891ac1bc4eb63af7409219d + # via + # onemkl-sycl-blas + # onemkl-sycl-dft + # onemkl-sycl-lapack + # onemkl-sycl-rng + # onemkl-sycl-sparse + # torch +einops==0.8.2 \ + --hash=sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193 \ + --hash=sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827 + # via -r deps/requirements_xpu.txt +fastapi==0.135.1 \ + --hash=sha256:46e2fc5745924b7c840f71ddd277382af29ce1cdb7d5eab5bf697e3fb9999c9e \ + --hash=sha256:d04115b508d936d254cea545b7312ecaa58a7b3a0f84952535b4c9afae7668cd + # via -r deps/requirements_xpu.txt +filelock==3.25.2 \ + --hash=sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694 \ + --hash=sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70 + # via + # -r deps/requirements_xpu.txt + # huggingface-hub + # torch + # transformers +frozenlist==1.8.0 \ + --hash=sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686 \ + --hash=sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0 \ + --hash=sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121 \ + --hash=sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd \ + --hash=sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7 \ + --hash=sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c \ + --hash=sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84 \ + --hash=sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d \ + --hash=sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b \ + --hash=sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79 \ + --hash=sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967 \ + --hash=sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f \ + --hash=sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4 \ + --hash=sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7 \ + --hash=sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef \ + --hash=sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9 \ + --hash=sha256:1a7607e17ad33361677adcd1443edf6f5da0ce5e5377b798fba20fae194825f3 \ + --hash=sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd \ + --hash=sha256:1aa77cb5697069af47472e39612976ed05343ff2e84a3dcf15437b232cbfd087 \ + --hash=sha256:1b9290cf81e95e93fdf90548ce9d3c1211cf574b8e3f4b3b7cb0537cf2227068 \ + --hash=sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7 \ + --hash=sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed \ + --hash=sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b \ + --hash=sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f \ + --hash=sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25 \ + --hash=sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe \ + --hash=sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143 \ + --hash=sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e \ + --hash=sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930 \ + --hash=sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37 \ + --hash=sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128 \ + --hash=sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2 \ + --hash=sha256:332db6b2563333c5671fecacd085141b5800cb866be16d5e3eb15a2086476675 \ + --hash=sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f \ + --hash=sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746 \ + --hash=sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df \ + --hash=sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8 \ + --hash=sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c \ + --hash=sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0 \ + --hash=sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad \ + --hash=sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82 \ + --hash=sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29 \ + --hash=sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c \ + --hash=sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30 \ + --hash=sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf \ + --hash=sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62 \ + --hash=sha256:48e6d3f4ec5c7273dfe83ff27c91083c6c9065af655dc2684d2c200c94308bb5 \ + --hash=sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383 \ + --hash=sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c \ + --hash=sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52 \ + --hash=sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d \ + --hash=sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1 \ + --hash=sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a \ + --hash=sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714 \ + --hash=sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65 \ + --hash=sha256:59a6a5876ca59d1b63af8cd5e7ffffb024c3dc1e9cf9301b21a2e76286505c95 \ + --hash=sha256:5a3a935c3a4e89c733303a2d5a7c257ea44af3a56c8202df486b7f5de40f37e1 \ + --hash=sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506 \ + --hash=sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888 \ + --hash=sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6 \ + --hash=sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41 \ + --hash=sha256:6dc4126390929823e2d2d9dc79ab4046ed74680360fc5f38b585c12c66cdf459 \ + --hash=sha256:7398c222d1d405e796970320036b1b563892b65809d9e5261487bb2c7f7b5c6a \ + --hash=sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608 \ + --hash=sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa \ + --hash=sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8 \ + --hash=sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1 \ + --hash=sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186 \ + --hash=sha256:7bf6cdf8e07c8151fba6fe85735441240ec7f619f935a5205953d58009aef8c6 \ + --hash=sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed \ + --hash=sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e \ + --hash=sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52 \ + --hash=sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231 \ + --hash=sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450 \ + --hash=sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496 \ + --hash=sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a \ + --hash=sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3 \ + --hash=sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24 \ + --hash=sha256:940d4a017dbfed9daf46a3b086e1d2167e7012ee297fef9e1c545c4d022f5178 \ + --hash=sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695 \ + --hash=sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7 \ + --hash=sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4 \ + --hash=sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e \ + --hash=sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e \ + --hash=sha256:9ff15928d62a0b80bb875655c39bf517938c7d589554cbd2669be42d97c2cb61 \ + --hash=sha256:a6483e309ca809f1efd154b4d37dc6d9f61037d6c6a81c2dc7a15cb22c8c5dca \ + --hash=sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad \ + --hash=sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b \ + --hash=sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a \ + --hash=sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8 \ + --hash=sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51 \ + --hash=sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011 \ + --hash=sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8 \ + --hash=sha256:b4f3b365f31c6cd4af24545ca0a244a53688cad8834e32f56831c4923b50a103 \ + --hash=sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b \ + --hash=sha256:b9be22a69a014bc47e78072d0ecae716f5eb56c15238acca0f43d6eb8e4a5bda \ + --hash=sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806 \ + --hash=sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042 \ + --hash=sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e \ + --hash=sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b \ + --hash=sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef \ + --hash=sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d \ + --hash=sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567 \ + --hash=sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a \ + --hash=sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2 \ + --hash=sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0 \ + --hash=sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e \ + --hash=sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b \ + --hash=sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d \ + --hash=sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a \ + --hash=sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52 \ + --hash=sha256:d8b7138e5cd0647e4523d6685b0eac5d4be9a184ae9634492f25c6eb38c12a47 \ + --hash=sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1 \ + --hash=sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94 \ + --hash=sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f \ + --hash=sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff \ + --hash=sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822 \ + --hash=sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a \ + --hash=sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11 \ + --hash=sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581 \ + --hash=sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51 \ + --hash=sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565 \ + --hash=sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40 \ + --hash=sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92 \ + --hash=sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2 \ + --hash=sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5 \ + --hash=sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4 \ + --hash=sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93 \ + --hash=sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027 \ + --hash=sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd + # via + # aiohttp + # aiosignal +fsspec==2026.2.0 \ + --hash=sha256:6544e34b16869f5aacd5b90bdf1a71acb37792ea3ddf6125ee69a22a53fb8bff \ + --hash=sha256:98de475b5cb3bd66bedd5c4679e87b4fdfe1a3bf4d707b151b3c07e58c9a2437 + # via + # huggingface-hub + # torch +grpcio==1.78.0 \ + --hash=sha256:082653eecbdf290e6e3e2c276ab2c54b9e7c299e07f4221872380312d8cf395e \ + --hash=sha256:10a9a644b5dd5aec3b82b5b0b90d41c0fa94c85ef42cb42cf78a23291ddb5e7d \ + --hash=sha256:12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9 \ + --hash=sha256:185dea0d5260cbb2d224c507bf2a5444d5abbb1fa3594c1ed7e4c709d5eb8383 \ + --hash=sha256:1afa62af6e23f88629f2b29ec9e52ec7c65a7176c1e0a83292b93c76ca882558 \ + --hash=sha256:2045397e63a7a0ee7957c25f7dbb36ddc110e0cfb418403d110c0a7a68a844e9 \ + --hash=sha256:207db540302c884b8848036b80db352a832b99dfdf41db1eb554c2c2c7800f65 \ + --hash=sha256:271c73e6e5676afe4fc52907686670c7cea22ab2310b76a59b678403ed40d670 \ + --hash=sha256:2777b783f6c13b92bd7b716667452c329eefd646bfb3f2e9dabea2e05dbd34f6 \ + --hash=sha256:2bf5e2e163b356978b23652c4818ce4759d40f4712ee9ec5a83c4be6f8c23a3a \ + --hash=sha256:35eb275bf1751d2ffbd8f57cdbc46058e857cf3971041521b78b7db94bdaf127 \ + --hash=sha256:391e93548644e6b2726f1bb84ed60048d4bcc424ce5e4af0843d28ca0b754fec \ + --hash=sha256:3c586ac70e855c721bda8f548d38c3ca66ac791dc49b66a8281a1f99db85e452 \ + --hash=sha256:3f8904a8165ab21e07e58bf3e30a73f4dffc7a1e0dbc32d51c61b5360d26f43e \ + --hash=sha256:459ab414b35f4496138d0ecd735fed26f1318af5e52cb1efbc82a09f0d5aa911 \ + --hash=sha256:4c5533d03a6cbd7f56acfc9cfb44ea64f63d29091e40e44010d34178d392d7eb \ + --hash=sha256:51b13f9aed9d59ee389ad666b8c2214cc87b5de258fa712f9ab05f922e3896c6 \ + --hash=sha256:5361a0630a7fdb58a6a97638ab70e1dae2893c4d08d7aba64ded28bb9e7a29df \ + --hash=sha256:5397fff416b79e4b284959642a4e95ac4b0f1ece82c9993658e0e477d40551ec \ + --hash=sha256:57bab6deef2f4f1ca76cc04565df38dc5713ae6c17de690721bdf30cb1e0545c \ + --hash=sha256:6092beabe1966a3229f599d7088b38dfc8ffa1608b5b5cdda31e591e6500f856 \ + --hash=sha256:684083fd383e9dc04c794adb838d4faea08b291ce81f64ecd08e4577c7398adf \ + --hash=sha256:735e38e176a88ce41840c21bb49098ab66177c64c82426e24e0082500cc68af5 \ + --hash=sha256:7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5 \ + --hash=sha256:748b6138585379c737adc08aeffd21222abbda1a86a0dca2a39682feb9196c20 \ + --hash=sha256:74be1268d1439eaaf552c698cdb11cd594f0c49295ae6bb72c34ee31abbe611b \ + --hash=sha256:7cc47943d524ee0096f973e1081cb8f4f17a4615f2116882a5f1416e4cfe92b5 \ + --hash=sha256:859b13906ce098c0b493af92142ad051bf64c7870fa58a123911c88606714996 \ + --hash=sha256:85f93781028ec63f383f6bc90db785a016319c561cc11151fbb7b34e0d012303 \ + --hash=sha256:86ce2371bfd7f212cf60d8517e5e854475c2c43ce14aa910e136ace72c6db6c1 \ + --hash=sha256:86f85dd7c947baa707078a236288a289044836d4b640962018ceb9cd1f899af5 \ + --hash=sha256:8dfffba826efcf366b1e3ccc37e67afe676f290e13a3b48d31a46739f80a8724 \ + --hash=sha256:8f2ac84905d12918e4e55a16da17939eb63e433dc11b677267c35568aa63fc84 \ + --hash=sha256:94309f498bcc07e5a7d16089ab984d42ad96af1d94b5a4eb966a266d9fcabf68 \ + --hash=sha256:94f95cf5d532d0e717eed4fc1810e8e6eded04621342ec54c89a7c2f14b581bf \ + --hash=sha256:9566fe4ababbb2610c39190791e5b829869351d14369603702e890ef3ad2d06e \ + --hash=sha256:9dca934f24c732750389ce49d638069c3892ad065df86cb465b3fa3012b70c9e \ + --hash=sha256:a9f136fbafe7ccf4ac7e8e0c28b31066e810be52d6e344ef954a3a70234e1702 \ + --hash=sha256:ab399ef5e3cd2a721b1038a0f3021001f19c5ab279f145e1146bb0b9f1b2b12c \ + --hash=sha256:b0c689c02947d636bc7fab3e30cc3a3445cca99c834dfb77cd4a6cabfc1c5597 \ + --hash=sha256:b2342d87af32790f934a79c3112641e7b27d63c261b8b4395350dad43eff1dc7 \ + --hash=sha256:b58f37edab4a3881bc6c9bca52670610e0c9ca14e2ea3cf9debf185b870457fb \ + --hash=sha256:bd8cb8026e5f5b50498a3c4f196f57f9db344dad829ffae16b82e4fdbaea2813 \ + --hash=sha256:be63c88b32e6c0f1429f1398ca5c09bc64b0d80950c8bb7807d7d7fb36fb84c7 \ + --hash=sha256:c3f293fdc675ccba4db5a561048cca627b5e7bd1c8a6973ffedabe7d116e22e2 \ + --hash=sha256:c41bc64626db62e72afec66b0c8a0da76491510015417c127bfc53b2fe6d7f7f \ + --hash=sha256:ce3a90455492bf8bfa38e56fbbe1dbd4f872a3d8eeaf7337dc3b1c8aa28c271b \ + --hash=sha256:ce7599575eeb25c0f4dc1be59cada6219f3b56176f799627f44088b21381a28a \ + --hash=sha256:dce09d6116df20a96acfdbf85e4866258c3758180e8c49845d6ba8248b6d0bbb \ + --hash=sha256:de8cb00d1483a412a06394b8303feec5dcb3b55f81d83aa216dbb6a0b86a94f5 \ + --hash=sha256:df2c8f3141f7cbd112a6ebbd760290b5849cda01884554f7c67acc14e7b1758a \ + --hash=sha256:e87cbc002b6f440482b3519e36e1313eb5443e9e9e73d6a52d43bd2004fcfd8e \ + --hash=sha256:e888474dee2f59ff68130f8a397792d8cb8e17e6b3434339657ba4ee90845a8c \ + --hash=sha256:f12857d24d98441af6a1d5c87442d624411db486f7ba12550b07788f74b67b04 \ + --hash=sha256:f2d4e43ee362adfc05994ed479334d5a451ab7bc3f3fee1b796b8ca66895acb4 \ + --hash=sha256:f3d6379493e18ad4d39537a82371c5281e153e963cecb13f953ebac155756525 \ + --hash=sha256:f8dff3d9777e5d2703a962ee5c286c239bf0ba173877cc68dc02c17d042e29de \ + --hash=sha256:f9ab915a267fc47c7e88c387a3a28325b58c898e23d4995f765728f4e3dedb97 \ + --hash=sha256:fbe6e89c7ffb48518384068321621b2a69cab509f58e40e4399fdd378fa6d074 \ + --hash=sha256:fd5f135b1bd58ab088930b3c613455796dfa0393626a6972663ccdda5b4ac6ce \ + --hash=sha256:ff870aebe9a93a85283837801d35cd5f8814fe2ad01e606861a7fb47c762a2b7 + # via + # -r deps/requirements_xpu.txt + # grpcio-tools +grpcio-tools==1.78.0 \ + --hash=sha256:0197d7b561c79be78ab93d0fe2836c8def470683df594bae3ac89dd8e5c821b2 \ + --hash=sha256:05803a5cdafe77c8bdf36aa660ad7a6a1d9e49bc59ce45c1bade2a4698826599 \ + --hash=sha256:0c676d8342fd53bd85a5d5f0d070cd785f93bc040510014708ede6fcb32fada1 \ + --hash=sha256:1872d01f984c85ee49ce581fcaffbcc9c792692b4b5ebf9bba4358fc895c316a \ + --hash=sha256:217d1fa29de14d9c567d616ead7cb0fef33cde36010edff5a9390b00d52e5094 \ + --hash=sha256:21b31c87cef35af124f1cfb105614725b462656d2684f59d05a6210266b17b9e \ + --hash=sha256:2250e8424c565a88573f7dc10659a0b92802e68c2a1d57e41872c9b88ccea7a6 \ + --hash=sha256:275ce3c2978842a8cf9dd88dce954e836e590cf7029649ad5d1145b779039ed5 \ + --hash=sha256:283239ddbb67ae83fac111c61b25d8527a1dbd355b377cbc8383b79f1329944d \ + --hash=sha256:28f71f591f7f39555863ced84fcc209cbf4454e85ef957232f43271ee99af577 \ + --hash=sha256:2921d7989c4d83b71f03130ab415fa4d66e6693b8b8a1fcbb7a1c67cff19b812 \ + --hash=sha256:2afeaad88040894c76656202ff832cb151bceb05c0e6907e539d129188b1e456 \ + --hash=sha256:2d6de1cc23bdc1baafc23e201b1e48c617b8c1418b4d8e34cebf72141676e5fb \ + --hash=sha256:2ed51ce6b833068f6c580b73193fc2ec16468e6bc18354bc2f83a58721195a58 \ + --hash=sha256:2f8ea092a7de74c6359335d36f0674d939a3c7e1a550f4c2c9e80e0226de8fe4 \ + --hash=sha256:30b1eef2afb6f2c3deb94525d60aedfea807d4937b5e23ad72600e3f8cd1c768 \ + --hash=sha256:33cc593735c93c03d63efe7a8ba25f3c66f16c52f0651910712490244facad72 \ + --hash=sha256:394e8b57d85370a62e5b0a4d64c96fcf7568345c345d8590c821814d227ecf1d \ + --hash=sha256:4003fcd5cbb5d578b06176fd45883a72a8f9203152149b7c680ce28653ad9e3a \ + --hash=sha256:4b0dd86560274316e155d925158276f8564508193088bc43e20d3f5dff956b2b \ + --hash=sha256:4bb6ed690d417b821808796221bde079377dff98fdc850ac157ad2f26cda7a36 \ + --hash=sha256:4eff49de5f8f320ed2a69bbb6bfe512175b1762d736cfce28aca0129939f7252 \ + --hash=sha256:4fab1faa3fbcb246263e68da7a8177d73772283f9db063fb8008517480888d26 \ + --hash=sha256:4ff605e25652a0bd13aa8a73a09bc48669c68170902f5d2bf1468a57d5e78771 \ + --hash=sha256:553ff18c5d52807dedecf25045ae70bad7a3dbba0b27a9a3cdd9bcf0a1b7baec \ + --hash=sha256:5a6de495dabf86a3b40b9a7492994e1232b077af9d63080811838b781abbe4e8 \ + --hash=sha256:5c8ceb32cd818e40739529b3c3143a30c899c247db22a6275c4798dece9a4ae7 \ + --hash=sha256:638fa11b4731dce2c662f685c3be0489246e8d2306654eb26ebd71e6a24c4b70 \ + --hash=sha256:6993b960fec43a8d840ee5dc20247ef206c1a19587ea49fe5e6cc3d2a09c1585 \ + --hash=sha256:6a8b8b7b49f319d29dbcf507f62984fa382d1d10437d75c3f26db5f09c4ac0af \ + --hash=sha256:6ddf7e7a7d069e7287b9cb68937102efe1686e63117a162d01578ac2839b4acd \ + --hash=sha256:77e5aa2d2a7268d55b1b113f958264681ef1994c970f69d48db7d4683d040f57 \ + --hash=sha256:7d58ade518b546120ec8f0a8e006fc8076ae5df151250ebd7e82e9b5e152c229 \ + --hash=sha256:7e989ad2cd93db52d7f1a643ecaa156ac55bf0484f1007b485979ce8aef62022 \ + --hash=sha256:87e648759b06133199f4bc0c0053e3819f4ec3b900dc399e1097b6065db998b5 \ + --hash=sha256:8b080d0d072e6032708a3a91731b808074d7ab02ca8fb9847b6a011fdce64cd9 \ + --hash=sha256:8c0ad8f8f133145cd7008b49cb611a5c6a9d89ab276c28afa17050516e801f79 \ + --hash=sha256:8c7f5e4af5a84d2e96c862b1a65e958a538237e268d5f8203a3a784340975b51 \ + --hash=sha256:8e3c0b0e6ba5275322ba29a97bf890565a55f129f99a21b121145e9e93a22525 \ + --hash=sha256:96183e2b44afc3f9a761e9d0f985c3b44e03e8bb98e626241a6cbfb3b6f7e88f \ + --hash=sha256:975d4cb48694e20ebd78e1643e5f1cd94cdb6a3d38e677a8e84ae43665aa4790 \ + --hash=sha256:9eb122da57d4cad7d339fc75483116f0113af99e8d2c67f3ef9cae7501d806e4 \ + --hash=sha256:a3ef700293ab375e111a2909d87434ed0a0b086adf0ce67a8d9cf12ea7765e63 \ + --hash=sha256:ac977508c0db15301ef36d6c79769ec1a6cc4e3bc75735afca7fe7e360cead3a \ + --hash=sha256:b81b4cf356272512172a604d4467af9b373de69cd69e1ac163fb41f7dac33099 \ + --hash=sha256:b874991797e96c41a37e563236c3317ed41b915eff25b292b202d6277d30da85 \ + --hash=sha256:c70b07b2610db3743d831700301eb17a9e1de2818d1f36ad53cb5b8b593a5749 \ + --hash=sha256:d0c501b8249940b886420e6935045c44cb818fa6f265f4c2b97d5cff9cb5e796 \ + --hash=sha256:d62cf3b68372b0c6d722a6165db41b976869811abeabc19c8522182978d8db10 \ + --hash=sha256:da422985e0cac822b41822f43429c19ecb27c81ffe3126d0b74e77edec452608 \ + --hash=sha256:daa8c288b728228377aaf758925692fc6068939d9fa32f92ca13dedcbeb41f33 \ + --hash=sha256:dd9c094f73f734becae3f20f27d4944d3cd8fb68db7338ee6c58e62fc5c3d99f \ + --hash=sha256:e3191af125dcb705aa6bc3856ba81ba99b94121c1b6ebee152e66ea084672831 \ + --hash=sha256:e6a0df438e82c804c7b95e3f311c97c2f876dcc36376488d5b736b7bcf5a9b45 \ + --hash=sha256:e9c6070a9500798225191ef25d0055a15d2c01c9c8f2ee7b681fffa99c98c822 \ + --hash=sha256:ea64e38d1caa2b8468b08cb193f5a091d169b6dbfe1c7dac37d746651ab9d84e \ + --hash=sha256:f3d3ced52bfe39eba3d24f5a8fab4e12d071959384861b41f0c52ca5399d6920 \ + --hash=sha256:f6d53392eb0f758eaa9ecfa6f9aab1e1f3c9db117a4242c802a30363fdc404d2 \ + --hash=sha256:f7c722e9ce6f11149ac5bddd5056e70aaccfd8168e74e9d34d8b8b588c3f5c7c \ + --hash=sha256:fa9056742efeaf89d5fe14198af71e5cbc4fbf155d547b89507e19d6025906c6 \ + --hash=sha256:fe6b0081775394c61ec633c9ff5dbc18337100eabb2e946b5c83967fe43b2748 + # via -r deps/requirements_xpu.txt +h11==0.16.0 \ + --hash=sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1 \ + --hash=sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86 + # via + # httpcore + # uvicorn +hf-xet==1.4.2 \ + --hash=sha256:09b138422ecbe50fd0c84d4da5ff537d27d487d3607183cd10e3e53f05188e82 \ + --hash=sha256:163aab46854ccae0ab6a786f8edecbbfbaa38fcaa0184db6feceebf7000c93c0 \ + --hash=sha256:2f45c712c2fa1215713db10df6ac84b49d0e1c393465440e9cb1de73ecf7bbf6 \ + --hash=sha256:32c012286b581f783653e718c1862aea5b9eb140631685bb0c5e7012c8719a87 \ + --hash=sha256:41659966020d59eb9559c57de2cde8128b706a26a64c60f0531fa2318f409418 \ + --hash=sha256:4642a6cf249c09da8c1f87fe50b24b2a3450b235bf8adb55700b52f0ea6e2eb6 \ + --hash=sha256:5b2e0132c56d7ee1bf55bdb638c4b62e7106f6ac74f0b786fed499d5548c5570 \ + --hash=sha256:5c588e21d80010119458dd5d02a69093f0d115d84e3467efe71ffb2c67c19146 \ + --hash=sha256:6b0932eb8b10317ea78b7da6bab172b17be03bbcd7809383d8d5abd6a2233e04 \ + --hash=sha256:6d2f8ee39fa9fba9af929f8c0d0482f8ee6e209179ad14a909b6ad78ffcb7c81 \ + --hash=sha256:6d53df40616f7168abfccff100d232e9d460583b9d86fa4912c24845f192f2b8 \ + --hash=sha256:71f02d6e4cdd07f344f6844845d78518cc7186bd2bc52d37c3b73dc26a3b0bc5 \ + --hash=sha256:769431385e746c92dc05492dde6f687d304584b89c33d79def8367ace06cb555 \ + --hash=sha256:77e8c180b7ef12d8a96739a4e1e558847002afe9ea63b6f6358b2271a8bdda1c \ + --hash=sha256:949dcf88b484bb9d9276ca83f6599e4aa03d493c08fc168c124ad10b2e6f75d7 \ + --hash=sha256:9d9a634cc929cfbaf2e1a50c0e532ae8c78fa98618426769480c58501e8c8ac2 \ + --hash=sha256:a296744d771a8621ad1d50c098d7ab975d599800dae6d48528ba3944e5001ba0 \ + --hash=sha256:ac8202ae1e664b2c15cdfc7298cbb25e80301ae596d602ef7870099a126fcad4 \ + --hash=sha256:ad185719fb2e8ac26f88c8100562dbf9dbdcc3d9d2add00faa94b5f106aea53f \ + --hash=sha256:b7457b6b482d9e0743bd116363239b1fa904a5e65deede350fbc0c4ea67c71ea \ + --hash=sha256:c3b3c6a882016b94b6c210957502ff7877802d0dbda8ad142c8595db8b944271 \ + --hash=sha256:c9dd1c1bc4cc56168f81939b0e05b4c36dd2d28c13dc1364b17af89aa0082496 \ + --hash=sha256:e9b38d876e94d4bdcf650778d6ebbaa791dd28de08db9736c43faff06ede1b5a \ + --hash=sha256:f563f7efe49588b7d0629d18d36f46d1658fe7e08dce3fa3d6526e1c98315e2d \ + --hash=sha256:fca58a2ae4e6f6755cc971ac6fcdf777ea9284d7e540e350bb000813b9a3008d + # via huggingface-hub +httpcore==1.0.9 \ + --hash=sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55 \ + --hash=sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8 + # via httpx +httpx==0.28.1 \ + --hash=sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc \ + --hash=sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad + # via openai +huggingface-hub==0.36.2 \ + --hash=sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a \ + --hash=sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270 + # via + # sentence-transformers + # timm + # tokenizers + # transformers +idna==3.11 \ + --hash=sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea \ + --hash=sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902 + # via + # anyio + # httpx + # requests + # yarl +impi-rt==2021.17.0 \ + --hash=sha256:34993304c1034474f1b52b94e484807029d571e246c1c842bab2dce44252c20a \ + --hash=sha256:7b65c5a5e9df8a2fe0cc98ee5a44ea4e18f90e7d11847ab6b9f9b0df59c1d03a + # via + # oneccl + # torch +importlib-metadata==8.7.1 \ + --hash=sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb \ + --hash=sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151 + # via -r deps/requirements_xpu.txt +intel-cmplr-lib-rt==2025.3.1 \ + --hash=sha256:57f657aa49442723e59102fb9e3f5eb70799d9371eca7ab2ad46f44facf210cf \ + --hash=sha256:dbae2c6d5163b8e5cfe20946cf6c63b65b05847bb79e33303bf2e35f86fd8523 + # via + # intel-sycl-rt + # torch +intel-cmplr-lib-ur==2025.3.1 \ + --hash=sha256:1730cce0c65591d157d5fa1acdc8447a9ed419b527ea52e66db0815a0fb5e444 \ + --hash=sha256:f34122b85a5e7747566643719fde8a547f7f8e73994c2b8c539c2c789d708f02 + # via + # intel-openmp + # intel-sycl-rt + # torch +intel-cmplr-lic-rt==2025.3.1 \ + --hash=sha256:ad651c2690692bf8c940ee65a26bb063d06959a7e2ad27722f6edbbf1f53ca46 \ + --hash=sha256:c6d327bdc5a5dd28473181caf716348890e2c6daf07da86d4e036c38a9810199 + # via + # intel-opencl-rt + # intel-sycl-rt + # torch +intel-opencl-rt==2025.3.1 \ + --hash=sha256:f54c797fd839b9e5e441c894eab0e1adc8394a06b3c4df3804522d6005a661d9 \ + --hash=sha256:f91556db0590d3169a9ef183e1081ad414d29d23d809835ffa531621c8dd1f2e + # via + # dpcpp-cpp-rt + # onemkl-sycl-blas + # onemkl-sycl-dft + # onemkl-sycl-lapack + # onemkl-sycl-rng + # onemkl-sycl-sparse + # torch +intel-openmp==2025.3.1 \ + --hash=sha256:2c3541ea275f0e8417243612a16b6f1f4d15c1e9fcc96667db0824d0735f1413 \ + --hash=sha256:bf325e802d9f52f95ca8d2558bb66f30d1839aed30426533063a78a3587e9035 + # via + # dpcpp-cpp-rt + # mkl + # torch +intel-pti==0.15.0 \ + --hash=sha256:629fbdfb4c1701987dcc9f8e2c03fc18b3ec9ab5c8462ee9de71c96c62b82ecc \ + --hash=sha256:8b894cb650c0dfc30723beca4a469b59af66e9ae460b759c8d2c1f78d05a2163 + # via torch +intel-sycl-rt==2025.3.1 \ + --hash=sha256:296d94598e150bf6ea4c5a8f1505f98e8a483bf38b6935b8ddad6f72b1d25b9f \ + --hash=sha256:a663c9d42a02492c2c159d33c82822e2329f7e46be508ad37bdc3e7940515fe5 + # via + # dpcpp-cpp-rt + # oneccl + # torch +jieba==0.42.1 \ + --hash=sha256:055ca12f62674fafed09427f176506079bc135638a14e23e25be909131928db2 + # via -r deps/requirements_xpu.txt +jinja2==3.1.6 \ + --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \ + --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67 + # via + # -r deps/requirements_xpu.txt + # torch +jiter==0.13.0 \ + --hash=sha256:00203f47c214156df427b5989de74cb340c65c8180d09be1bf9de81d0abad599 \ + --hash=sha256:04670992b576fa65bd056dbac0c39fe8bd67681c380cb2b48efa885711d9d726 \ + --hash=sha256:0733312953b909688ae3c2d58d043aa040f9f1a6a75693defed7bc2cc4bf2654 \ + --hash=sha256:07b75fe09a4ee8e0c606200622e571e44943f47254f95e2436c8bdcaceb36d7d \ + --hash=sha256:0a2bd69fc1d902e89925fc34d1da51b2128019423d7b339a45d9e99c894e0663 \ + --hash=sha256:0a8d76c7524087272c8ae913f5d9d608bd839154b62c4322ef65723d2e5bb0b8 \ + --hash=sha256:0b34c519e17658ed88d5047999a93547f8889f3c1824120c26ad6be5f27b6cf5 \ + --hash=sha256:0bf670e3b1445fc4d31612199f1744f67f889ee1bbae703c4b54dc097e5dd394 \ + --hash=sha256:0c365005b05505a90d1c47856420980d0237adf82f70c4aff7aebd3c1cc143ad \ + --hash=sha256:0e3a5f0cde8ff433b8e88e41aa40131455420fb3649a3c7abdda6145f8cb7202 \ + --hash=sha256:0f0c065695f616a27c920a56ad0d4fc46415ef8b806bf8fc1cacf25002bd24e1 \ + --hash=sha256:1211427574b17b633cfceba5040de8081e5abf114f7a7602f73d2e16f9fdaa59 \ + --hash=sha256:1317fdffd16f5873e46ce27d0e0f7f4f90f0cdf1d86bf6abeaea9f63ca2c401d \ + --hash=sha256:15db60e121e11fe186c0b15236bd5d18381b9ddacdcf4e659feb96fc6c969c92 \ + --hash=sha256:19928b5d1ce0ff8c1ee1b9bdef3b5bfc19e8304f1b904e436caf30bc15dc6cf5 \ + --hash=sha256:19cd6f85e1dc090277c3ce90a5b7d96f32127681d825e71c9dce28788e39fc0c \ + --hash=sha256:1f4748aad1b4a93c8bdd70f604d0f748cdc0e8744c5547798acfa52f10e79228 \ + --hash=sha256:1f8a55b848cbabf97d861495cd65f1e5c590246fabca8b48e1747c4dfc8f85bf \ + --hash=sha256:2113c17c9a67071b0f820733c0893ed1d467b5fcf4414068169e5c2cabddb1e2 \ + --hash=sha256:24ab43126d5e05f3d53a36a8e11eb2f23304c6c1117844aaaf9a0aa5e40b5018 \ + --hash=sha256:24dc96eca9f84da4131cdf87a95e6ce36765c3b156fc9ae33280873b1c32d5f6 \ + --hash=sha256:2b4972c6df33731aac0742b64fd0d18e0a69bc7d6e03108ce7d40c85fd9e3e6d \ + --hash=sha256:2c26cf47e2cad140fa23b6d58d435a7c0161f5c514284802f25e87fddfe11024 \ + --hash=sha256:2d08c9475d48b92892583df9da592a0e2ac49bcd41fae1fec4f39ba6cf107820 \ + --hash=sha256:2ffc63785fd6c7977defe49b9824ae6ce2b2e2b77ce539bdaf006c26da06342e \ + --hash=sha256:309549b778b949d731a2f0e1594a3f805716be704a73bf3ad9a807eed5eb5721 \ + --hash=sha256:3097d665a27bc96fd9bbf7f86178037db139f319f785e4757ce7ccbf390db6c2 \ + --hash=sha256:36ebfbcffafb146d0e6ffb3e74d51e03d9c35ce7c625c8066cdbfc7b953bdc72 \ + --hash=sha256:3b3fb8c2053acaef8580809ac1d1f7481a0a0bdc012fd7f5d8b18fb696a5a089 \ + --hash=sha256:3d744a6061afba08dd7ae375dcde870cffb14429b7477e10f67e9e6d68772a0a \ + --hash=sha256:41f92313d17989102f3cb5dd533a02787cdb99454d494344b0361355da52fcb9 \ + --hash=sha256:4397ee562b9f69d283e5674445551b47a5e8076fdde75e71bfac5891113dc543 \ + --hash=sha256:45f6f8efb2f3b0603092401dc2df79fa89ccbc027aaba4174d2d4133ed661434 \ + --hash=sha256:47455245307e4debf2ce6c6e65a717550a0244231240dcf3b8f7d64e4c2f22f4 \ + --hash=sha256:4a638816427006c1e3f0013eb66d391d7a3acda99a7b0cf091eff4497ccea33a \ + --hash=sha256:5467696f6b827f1116556cb0db620440380434591e93ecee7fd14d1a491b6daa \ + --hash=sha256:57aab48f40be1db920a582b30b116fe2435d184f77f0e4226f546794cedd9cf0 \ + --hash=sha256:597245258e6ad085d064780abfb23a284d418d3e61c57362d9449c6c7317ee2d \ + --hash=sha256:5a1aff1fbdb803a376d4d22a8f63f8e7ccbce0b4890c26cc7af9e501ab339ef0 \ + --hash=sha256:5d9b34ad56761b3bf0fbe8f7e55468704107608512350962d3317ffd7a4382d5 \ + --hash=sha256:6207fc61c395b26fffdcf637a0b06b4326f35bfa93c6e92fe1a166a21aeb6731 \ + --hash=sha256:632bf7c1d28421c00dd8bbb8a3bac5663e1f57d5cd5ed962bce3c73bf62608e6 \ + --hash=sha256:66aa3e663840152d18cc8ff1e4faad3dd181373491b9cfdc6004b92198d67911 \ + --hash=sha256:682161a67adea11e3aae9038c06c8b4a9a71023228767477d683f69903ebc607 \ + --hash=sha256:6c26a424569a59140fb51160a56df13f438a2b0967365e987889186d5fc2f6f9 \ + --hash=sha256:6eeb7db8bc77dc20476bc2f7407a23dbe3d46d9cc664b166e3d474e1c1de4baa \ + --hash=sha256:701a1e77d1e593c1b435315ff625fd071f0998c5f02792038a5ca98899261b7d \ + --hash=sha256:775e10de3849d0631a97c603f996f518159272db00fdda0a780f81752255ee9d \ + --hash=sha256:7772115877c53f62beeb8fd853cab692dbc04374ef623b30f997959a4c0e7e95 \ + --hash=sha256:7b88d649135aca526da172e48083da915ec086b54e8e73a425ba50999468cc08 \ + --hash=sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19 \ + --hash=sha256:7beae3a3d3b5212d3a55d2961db3c292e02e302feb43fce6a3f7a31b90ea6dfe \ + --hash=sha256:7c26ad6967c9dcedf10c995a21539c3aa57d4abad7001b7a84f621a263a6b605 \ + --hash=sha256:7f90023f8f672e13ea1819507d2d21b9d2d1c18920a3b3a5f1541955a85b5504 \ + --hash=sha256:879e768938e7b49b5e90b7e3fecc0dbec01b8cb89595861fb39a8967c5220d09 \ + --hash=sha256:87ce0f14c6c08892b610686ae8be350bf368467b6acd5085a5b65441e2bf36d2 \ + --hash=sha256:8d76029f077379374cf0dbc78dbe45b38dec4a2eb78b08b5194ce836b2517afc \ + --hash=sha256:9621ca242547edc16400981ca3231e0c91c0c4c1ab8573a596cd9bb3575d5c2b \ + --hash=sha256:964538479359059a35fb400e769295d4b315ae61e4105396d355a12f7fef09f0 \ + --hash=sha256:9776ebe51713acf438fd9b4405fcd86893ae5d03487546dae7f34993217f8a91 \ + --hash=sha256:98fbafb6e88256f4454de33c1f40203d09fc33ed19162a68b3b257b29ca7f663 \ + --hash=sha256:9950290340acc1adaded363edd94baebcee7dabdfa8bee4790794cd5cfad2af6 \ + --hash=sha256:9d01ecc3a8cbdb6f25a37bd500510550b64ddf9f7d64a107d92f3ccb25035d0f \ + --hash=sha256:9da38b4fedde4fb528c740c2564628fbab737166a0e73d6d46cb4bb5463ff411 \ + --hash=sha256:9ffda299e417dc83362963966c50cb76d42da673ee140de8a8ac762d4bb2378b \ + --hash=sha256:a13b68cd1cd8cc9de8f244ebae18ccb3e4067ad205220ef324c39181e23bbf66 \ + --hash=sha256:a3a377af27b236abbf665a69b2bdd680e3b5a0bd2af825cd3b81245279a7606c \ + --hash=sha256:a576f5dce9ac7de5d350b8e2f552cf364f32975ed84717c35379a51c7cb198bd \ + --hash=sha256:a7637d92b1c9d7a771e8c56f445c7f84396d48f2e756e5978840ecba2fac0894 \ + --hash=sha256:ab1185ca5c8b9491b55ebf6c1e8866b8f68258612899693e24a92c5fdb9455d5 \ + --hash=sha256:ab44b178f7981fcaea7e0a5df20e773c663d06ffda0198f1a524e91b2fde7e59 \ + --hash=sha256:ade8cb6ff5632a62b7dbd4757d8c5573f7a2e9ae285d6b5b841707d8363205ef \ + --hash=sha256:aed40e099404721d7fcaf5b89bd3b4568a4666358bcac7b6b15c09fb6252ab68 \ + --hash=sha256:b1cbfa133241d0e6bdab48dcdc2604e8ba81512f6bbd68ec3e8e1357dd3c316c \ + --hash=sha256:b22945be8425d161f2e536cdae66da300b6b000f1c0ba3ddf237d1bfd45d21b8 \ + --hash=sha256:bb7613e1a427cfcb6ea4544f9ac566b93d5bf67e0d48c787eca673ff9c9dff2b \ + --hash=sha256:bcdabaea26cb04e25df3103ce47f97466627999260290349a88c8136ecae0060 \ + --hash=sha256:bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93 \ + --hash=sha256:c05b450d37ba0c9e21c77fef1f205f56bcee2330bddca68d344baebfc55ae0df \ + --hash=sha256:c1b609e5cbd2f52bb74fb721515745b407df26d7b800458bd97cb3b972c29e7d \ + --hash=sha256:c1e2b199f446d3e82246b4fd9236d7cb502dc2222b18698ba0d986d2fecc6152 \ + --hash=sha256:c3524798e70655ff19aec58c7d05adb1f074fecff62da857ea9be2b908b6d701 \ + --hash=sha256:cc5223ab19fe25e2f0bf2643204ad7318896fe3729bf12fde41b77bfc4fafff0 \ + --hash=sha256:d2a6394e6af690d462310a86b53c47ad75ac8c21dc79f120714ea449979cb1d3 \ + --hash=sha256:db367d8be9fad6e8ebbac4a7578b7af562e506211036cba2c06c3b998603c3d2 \ + --hash=sha256:dc3ce84cfd4fa9628fe62c4f85d0d597a4627d4242cfafac32a12cc1455d00f7 \ + --hash=sha256:e104da1db1c0991b3eaed391ccd650ae8d947eab1480c733e5a3fb28d4313e40 \ + --hash=sha256:e404ea551d35438013c64b4f357b0474c7abf9f781c06d44fcaf7a14c69ff9e2 \ + --hash=sha256:e5562a0f0e90a6223b704163ea28e831bd3a9faa3512a711f031611e6b06c939 \ + --hash=sha256:ea026e70a9a28ebbdddcbcf0f1323128a8db66898a06eaad3a4e62d2f554d096 \ + --hash=sha256:ec7e287d7fbd02cb6e22f9a00dd9c9cd504c40a61f2c61e7e1f9690a82726b4c \ + --hash=sha256:ed0240dd1536a98c3ab55e929c60dfff7c899fecafcb7d01161b21a99fc8c363 \ + --hash=sha256:ed9bbc30f5d60a3bdf63ae76beb3f9db280d7f195dfcfa61af792d6ce912d159 \ + --hash=sha256:ee9da221dca6e0429c2704c1b3655fe7b025204a71d4d9b73390c759d776d165 \ + --hash=sha256:f22ef501c3f87ede88f23f9b11e608581c14f04db59b6a801f354397ae13739f \ + --hash=sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4 \ + --hash=sha256:f556aa591c00f2c45eb1b89f68f52441a016034d18b65da60e2d2875bbbf344a \ + --hash=sha256:f7e1d61da332ec412350463891923f960c3073cf1aae93b538f0bb4c8cd46efb \ + --hash=sha256:f917a04240ef31898182f76a332f508f2cc4b57d2b4d7ad2dbfebbfe167eb505 \ + --hash=sha256:fa476ab5dd49f3bf3a168e05f89358c75a17608dbabb080ef65f96b27c19ab10 \ + --hash=sha256:fe49d3ff6db74321f144dff9addd4a5874d3105ac5ba7c5b77fac099cfae31ae \ + --hash=sha256:ff732bd0a0e778f43d5009840f20b935e79087b4dc65bd36f1cd0f9b04b8ff7f + # via openai +jmespath==0.10.0 \ + --hash=sha256:b85d0567b8666149a93172712e68920734333c0ce7e89b78b3e987f71e5ed4f9 \ + --hash=sha256:cdf6525904cc597730141d61b36f2e4b8ecc257c420fa2f4549bac2c2d0cb72f + # via aliyun-python-sdk-core +joblib==1.5.3 \ + --hash=sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713 \ + --hash=sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3 + # via + # librosa + # scikit-learn +json5==0.14.0 \ + --hash=sha256:56cf861bab076b1178eb8c92e1311d273a9b9acea2ccc82c276abf839ebaef3a \ + --hash=sha256:b3f492fad9f6cdbced8b7d40b28b9b1c9701c5f561bef0d33b81c2ff433fefcb + # via -r deps/requirements_xpu.txt +lazy-loader==0.5 \ + --hash=sha256:717f9179a0dbed357012ddad50a5ad3d5e4d9a0b8712680d4e687f5e6e6ed9b3 \ + --hash=sha256:ab0ea149e9c554d4ffeeb21105ac60bed7f3b4fd69b1d2360a4add51b170b005 + # via librosa +librosa==0.11.0 \ + --hash=sha256:0b6415c4fd68bff4c29288abe67c6d80b587e0e1e2cfb0aad23e4559504a7fa1 \ + --hash=sha256:f5ed951ca189b375bbe2e33b2abd7e040ceeee302b9bbaeeffdfddb8d0ace908 + # via -r deps/requirements_xpu.txt +llvmlite==0.44.0 \ + --hash=sha256:07667d66a5d150abed9157ab6c0b9393c9356f229784a4385c02f99e94fc94d4 \ + --hash=sha256:1d671a56acf725bf1b531d5ef76b86660a5ab8ef19bb6a46064a705c6ca80aad \ + --hash=sha256:2fb7c4f2fb86cbae6dca3db9ab203eeea0e22d73b99bc2341cdf9de93612e930 \ + --hash=sha256:319bddd44e5f71ae2689859b7203080716448a3cd1128fb144fe5c055219d516 \ + --hash=sha256:40526fb5e313d7b96bda4cbb2c85cd5374e04d80732dd36a282d72a560bb6408 \ + --hash=sha256:41e3839150db4330e1b2716c0be3b5c4672525b4c9005e17c7597f835f351ce2 \ + --hash=sha256:46224058b13c96af1365290bdfebe9a6264ae62fb79b2b55693deed11657a8bf \ + --hash=sha256:5f79a728e0435493611c9f405168682bb75ffd1fbe6fc360733b850c80a026db \ + --hash=sha256:7202b678cdf904823c764ee0fe2dfe38a76981f4c1e51715b4cb5abb6cf1d9e8 \ + --hash=sha256:9c58867118bad04a0bb22a2e0068c693719658105e40009ffe95c7000fcde88e \ + --hash=sha256:9fbadbfba8422123bab5535b293da1cf72f9f478a65645ecd73e781f962ca614 \ + --hash=sha256:aa0097052c32bf721a4efc03bd109d335dfa57d9bffb3d4c24cc680711b8b4fc \ + --hash=sha256:ace564d9fa44bb91eb6e6d8e7754977783c68e90a471ea7ce913bff30bd62427 \ + --hash=sha256:c0143a5ef336da14deaa8ec26c5449ad5b6a2b564df82fcef4be040b9cacfea9 \ + --hash=sha256:c5d22c3bfc842668168a786af4205ec8e3ad29fb1bc03fd11fd48460d0df64c1 \ + --hash=sha256:cccf8eb28f24840f2689fb1a45f9c0f7e582dd24e088dcf96e424834af11f791 \ + --hash=sha256:d752f89e31b66db6f8da06df8b39f9b91e78c5feea1bf9e8c1fba1d1c24c065d \ + --hash=sha256:d8489634d43c20cd0ad71330dde1d5bc7b9966937a263ff1ec1cebb90dc50955 \ + --hash=sha256:eae7e2d4ca8f88f89d315b48c6b741dcb925d6a1042da694aa16ab3dd4cbd3a1 \ + --hash=sha256:eed7d5f29136bda63b6d7804c279e2b72e08c952b7c5df61f45db408e0ee52f3 \ + --hash=sha256:f01a394e9c9b7b1d4e63c327b096d10f6f0ed149ef53d38a09b3749dcf8c9610 + # via numba +lru-dict==1.4.1 \ + --hash=sha256:000ba9a2ab4dd1ad2d91764a6d5cce75a59de51534cdda478d1ddaa3cd8d5c48 \ + --hash=sha256:0158db85dfb2cd2fd2ddaa47709bdb073f814e0a8a149051b70b07e59ac83231 \ + --hash=sha256:018cd3b41224ca81eb83cdf6db024409a920e5c1d3ce4e8b323cb66e24a73132 \ + --hash=sha256:071468a716768a9afca64659c390c1abb6d937b1897e07a0b70383f75637fce0 \ + --hash=sha256:090c7b6a3d54fa7f3d69ba4802abe2f33c9583b16b33f52bcb521c701f7ea46c \ + --hash=sha256:11b289d78a48a086846e46d2275707d33523f5d543475336c29c56fd5d0e65dc \ + --hash=sha256:1671e8d92fe35dfb38d3505a56338792d3e225032f8e94888b6e95b323120380 \ + --hash=sha256:17844b4f8dd996144d53380395d73832e2508159ad49ed4fbcb62f1787a5feaf \ + --hash=sha256:1f185a9078e94c89127f5952a737a9060d807e5ef74f31dbcb755e9b03659a7b \ + --hash=sha256:2084363e4488aa5b4f8b26bd3cc148d70a15be92e3d347621a5b830b2b1e0a82 \ + --hash=sha256:22d5879ec5d5955f9dde105997bdf7ec9e0522bf99612a80b55b09f356a08368 \ + --hash=sha256:23424321b761c43f3021a596565f8205ecec0e175822e7a5d9b2a175578aa7de \ + --hash=sha256:24c779334bed82f1a7eb2d1ebcba2b7aa9a1555d40a3b53e05eb6b9dfcb0609c \ + --hash=sha256:2a5644bb1db0514abdad5e2f3d8f1beb6f7560c8cceb62079c40a4269de34b3c \ + --hash=sha256:2b569c7813adb753b7b631097c34e6dbc194cb1814f22299c2d2a94894779877 \ + --hash=sha256:2eb2058cb7b329b4b72baee4cd1bb322af1feec73de79e68edb35d333c90b698 \ + --hash=sha256:33cf1eb368d3989b8f00945937cfbfc2095d8ad2b1d2274ce1bde0af6f6d1e66 \ + --hash=sha256:3766e397aa6de1ca3442729bc1fa75834ab7b0a6b017e6e197d3a66b61abde59 \ + --hash=sha256:3910396142322fb2718546115bb2a56f50ebc9144b5140327053cca084e0d375 \ + --hash=sha256:3be24e24c8998302ea1c28f997505fa6843f507aad3c7d5c3a82cc01c5c11be4 \ + --hash=sha256:3d6770adafae25663b682420891a10a5894595f02b1e4d87766f7adc8e56e72a \ + --hash=sha256:3fe10c1f45712e191eecb2a69604d566c64ddfe01136fd467c890ed558c3ad40 \ + --hash=sha256:40927a6a4284d437047f547e652b15f6f0f40210deb6b9e5b77e556ff0faea0f \ + --hash=sha256:4209864be09ec20f6059fef8544697eb3d3729d63a983bf66457054bf3e40601 \ + --hash=sha256:43a9330e3cd8663a371c4ff54c7ff8142b2cc5ed63a53b774455e2846abe86ef \ + --hash=sha256:451f7249866cb9564bb40d73bec7ac865574dafd0a4cc91627bbf35be7e99291 \ + --hash=sha256:45d4dc338237cedcbacedab1afd9707b8f9867d8b601ec04e0395ec73f57405c \ + --hash=sha256:4617554f3e42a8f520c8494842c23b98f5b7f4d5e0410e91a4c3ad0ea5f7e094 \ + --hash=sha256:4c1b0540cbf2abd97574d110e5b540998d0634451ada11cac139e9dbc5220ad7 \ + --hash=sha256:4e0db4f3105108598749550e639b283b07df0bb91cac3b47e86ffebcab721cc7 \ + --hash=sha256:5534c69a52add5757714456d08ce3831d36b86c98972394ba900493bb0bd97f8 \ + --hash=sha256:5b31e9b6636f8945ad69c630c1891d810d62a91d99e792ef0b9ca865b6c26745 \ + --hash=sha256:64d7028b087e8b387fb16da7068cc3e9e70a79b284c838ba5e0302ec74aa7fdc \ + --hash=sha256:658e152d3a4ad0e1d75e6f53b1fa353779539920b38be99f4ea33d3bad41efdb \ + --hash=sha256:6699bfebbf11dd9ff1387be7996fac6d1009fe6a6f48091ef6e069e6f19c7bce \ + --hash=sha256:6ffbb6f3c1e906e92d9129c14a88d81358be1e0b60195c1729b215a52e9670de \ + --hash=sha256:73d7a97312ca50b26e78f676722631565e12f87d26cdfbdfd73f78d062265240 \ + --hash=sha256:74204239e30b8ec7976257c5b64565d7e3e8aea0cad0dd50a9b99e171aaf3898 \ + --hash=sha256:7558302ce8bbfcd29f08e695e07bf7a0d799c2979636d6a6a0b4e207f840969f \ + --hash=sha256:781dbcf0c83160e525482a4ebcd7c5065851a6c7295f1cda78248a2029f23f39 \ + --hash=sha256:78cf04c059867e8d1bbea1647c35a13e34fe902121c3e4671a5800210b6cbb07 \ + --hash=sha256:7b770c7db258625e57b6ea8e2e0503ba0fbbdcde374baacf9adb256eb9c5adfa \ + --hash=sha256:7fa342c6e6bc811ee6a17eb569d37b149340d5aa5a637a53438e316a95783838 \ + --hash=sha256:804ee76f98afc3d50e9a2e9c835a6820877aa6391f2add520a57f86b3f55ec3a \ + --hash=sha256:8198ab8ad7cc81b86340243ddd5cca882ead87daed0c9fa6cce377a10a7f2e47 \ + --hash=sha256:85b28aa2de7c5f1f6c68221857accd084438df98edbd4f57595795734225770c \ + --hash=sha256:85fc29363e2d3ba0a5f87b5e17f54b1078aea6d24c6dfc792725854b9d0f8d17 \ + --hash=sha256:885643fd968336d8652fddb0778184e2eeff7b7aebced6de268af6d6caef42d5 \ + --hash=sha256:8e73a1ec2d0f476d666ce7c91464b22854086951b319544d1850c508f5ce381f \ + --hash=sha256:8fc5732d5612d1c355ee834ed47854827f7dfe2c0a2dd1ee56a43fed4091bf72 \ + --hash=sha256:8fd6c12f48bb6f20b0306dd9627c1057513922ac576f00776a44bd3e125ee551 \ + --hash=sha256:8fef8dd72484b4280799c502c116acfdfcf0dedf3508bc9d0d19e684a6a23267 \ + --hash=sha256:906d99705b79a00b5668bdb8782ad823ccc8d26e1fc6b56327ae469a8d12e9b4 \ + --hash=sha256:9219f13e4101c064f70e1815d7c51f9be9e053983e74dfb7bcfdf92f5fcbb0e0 \ + --hash=sha256:96fd677b6d912229f2d02ba61a5a1210176963c4770c1bb765b8da937cec3834 \ + --hash=sha256:989ef7352b347c82e5d5047f3b7ddf34b5a938e3f7b08775cacc9f28e97dd2a8 \ + --hash=sha256:98af7044b5c3d85a649e1afb8891829ff5210caf9143acc741b3e98ab1b66ff6 \ + --hash=sha256:a276f8f6f43861c3f05986824741d00e3133a973c3396598375310129535382d \ + --hash=sha256:a36e6e95b5d474ef90d04a5e3ad81ca362b473ec9534ed964222f3c0444138b8 \ + --hash=sha256:a7da0e451faa4d6dcae21c0f2527c540000b2f23ed8326a0bc1d870130fd12b1 \ + --hash=sha256:a9bb130b5eaddd6453ca3dc38ce4a75f743512ad135b6f3994999dde0680bd79 \ + --hash=sha256:afdf92b332632aa6e4b8646e93723f50f41fece2a80a54d2b44e8ac67f913ceb \ + --hash=sha256:b0b5360264b37676c405ea0a560744d7dcb2d47adff1e7837113c15fabcc7a71 \ + --hash=sha256:b21688fd7ece56d04c0c13b42fd9f904d46fc9ff21e3de87d98f3f5a14c67f74 \ + --hash=sha256:b21d06dec64fb1952385262d9fcefaec147921dc0b55210007091a79da440d93 \ + --hash=sha256:b3853518dfa50f28af0d6e2dcf8bb8b0a1687c5f4eb913c0b35b0da5c6d276ce \ + --hash=sha256:b7e1ac7fb6e91e4d3212e153f9e2d98d163a4439b9bf9df247c22519262c26fe \ + --hash=sha256:b9613908a38cf8aa47f6c138ba031a8ac4ed38460299e84a2b07dba7b3b45aae \ + --hash=sha256:bb4b37daad9fe4e796c462f4876cf34e52564630902bdf59a271bc482b48a361 \ + --hash=sha256:bd86bd202a7c1585d9dc7e5b0c3d52cf76dc56b261b4bbecfeefbbae31a5c97d \ + --hash=sha256:c6099e2ecb118dfeae4a197bfcc702ea5841bfd86f19d1b340e932d0f5c47c10 \ + --hash=sha256:c8ac5cfd56e036bd8d7199626147044485fa64a163a5bde96bfa5a1c7fea2273 \ + --hash=sha256:cbbbb4b51e2529ccf7ee8a3c3b834052dbd54871a216cfd229dd2b1194ff293a \ + --hash=sha256:cc518ff2d38cc7a8ab56f9a6ae557f91e2e1524b57ed8e598e97f45a2bd708fc \ + --hash=sha256:cc74c49cf1c26d6c28d8f6988cf0354696ca38a4f6012fa63055d2800791784b \ + --hash=sha256:cc9dd191870555624bbf3903c8afa3f01815ca3256ed8b35cb323f0db3ce4f98 \ + --hash=sha256:d5f01ada0cf0c1aa2bdc684e5ac0f6548be7eccc3ce8b4c0361db8445f867f04 \ + --hash=sha256:d64ddbe4c426fdc4cfc1abaea71d587d439397386a7b35d588f4fd64b695a83d \ + --hash=sha256:d90774db1b60c0d5c829cfa5d7fda6db96ed1519296f626575598f9f170cca37 \ + --hash=sha256:e04820e3473bd7f55440f24c946ca4335e392d5e3e0e1e948020e94cd1954372 \ + --hash=sha256:e21f67ba374d1945051b547e719d44a8c7880718f67a15a03e7a12e1d12ea96b \ + --hash=sha256:e2c07ecb6d42494e45d00c2541e6b0ae7659fc3cf89681521ba94b15c682d4fe \ + --hash=sha256:e47040421a13de8bc6404557b3700c33f1f2683cbcce22fe5cacec4c938ce54b \ + --hash=sha256:e77d209bcd396eb236c197bf4c95fab6848c61e0c1a5031cdde7f5c787e209f4 \ + --hash=sha256:e84cd1065955897de01f1fb4cbd6f87cab7706e920283bb98c27341d76dd9a8d \ + --hash=sha256:e8996f3f94870ecb236c55d280839390edae7f201858fee770267eac27b8b47d \ + --hash=sha256:edc004c88911a8f9715e716116d2520c13db89afd6c37cc0f28042ba10635163 \ + --hash=sha256:ee7c3fe50c0c9efe04692fe0b3f52c8229e05e736d3274f188fb1db5de20e251 \ + --hash=sha256:f1f4ae6967d5873e684ce8b986e2e43985d0a1be735b09584737ad5634ff48f3 \ + --hash=sha256:f309b4018dd41f33bf3bd4cc0f62421da8bcca513ea044dbb22f3cd029935012 \ + --hash=sha256:f3f4fad5c4a9458954b275de6a6e31c67a26fbef7037c6a7354e22523a77db26 \ + --hash=sha256:f9335d46c83882a1b5deffed8098a2dd9ad66d2bd6263f416fc4c73f63e26904 \ + --hash=sha256:fc7544acfad4dd799f1a440ec51b01f19c53990275cc531e3657e857e6b427af \ + --hash=sha256:ff3af42922205620fdc920dcdf580c4c16b32c84a537a03b04b523e5c641a8a9 \ + --hash=sha256:ffad2758ce21d8fd6f0ae2628b31330732db8429a4b5994d2e107bed0ee11e68 \ + --hash=sha256:ffbb4eedc45eb629ca073795c53bf8de935a39cb58014b6af3487098d2f19098 + # via -r deps/requirements_xpu.txt +markupsafe==3.0.3 \ + --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \ + --hash=sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a \ + --hash=sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf \ + --hash=sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19 \ + --hash=sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf \ + --hash=sha256:0f4b68347f8c5eab4a13419215bdfd7f8c9b19f2b25520968adfad23eb0ce60c \ + --hash=sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175 \ + --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \ + --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \ + --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \ + --hash=sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab \ + --hash=sha256:15d939a21d546304880945ca1ecb8a039db6b4dc49b2c5a400387cdae6a62e26 \ + --hash=sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1 \ + --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \ + --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \ + --hash=sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634 \ + --hash=sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695 \ + --hash=sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad \ + --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \ + --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \ + --hash=sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe \ + --hash=sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa \ + --hash=sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559 \ + --hash=sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa \ + --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \ + --hash=sha256:3537e01efc9d4dccdf77221fb1cb3b8e1a38d5428920e0657ce299b20324d758 \ + --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \ + --hash=sha256:38664109c14ffc9e7437e86b4dceb442b0096dfe3541d7864d9cbe1da4cf36c8 \ + --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \ + --hash=sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c \ + --hash=sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97 \ + --hash=sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a \ + --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \ + --hash=sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9 \ + --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \ + --hash=sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc \ + --hash=sha256:591ae9f2a647529ca990bc681daebdd52c8791ff06c2bfa05b65163e28102ef2 \ + --hash=sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4 \ + --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \ + --hash=sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50 \ + --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \ + --hash=sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9 \ + --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \ + --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \ + --hash=sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115 \ + --hash=sha256:7c3fb7d25180895632e5d3148dbdc29ea38ccb7fd210aa27acbd1201a1902c6e \ + --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \ + --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \ + --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \ + --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \ + --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \ + --hash=sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d \ + --hash=sha256:949b8d66bc381ee8b007cd945914c721d9aba8e27f71959d750a46f7c282b20b \ + --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \ + --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \ + --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \ + --hash=sha256:a320721ab5a1aba0a233739394eb907f8c8da5c98c9181d1161e77a0c8e36f2d \ + --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \ + --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \ + --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \ + --hash=sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f \ + --hash=sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581 \ + --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \ + --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \ + --hash=sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c \ + --hash=sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026 \ + --hash=sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8 \ + --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \ + --hash=sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6 \ + --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \ + --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \ + --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \ + --hash=sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01 \ + --hash=sha256:df2449253ef108a379b8b5d6b43f4b1a8e81a061d6537becd5582fba5f9196d7 \ + --hash=sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419 \ + --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795 \ + --hash=sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1 \ + --hash=sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5 \ + --hash=sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d \ + --hash=sha256:e8fc20152abba6b83724d7ff268c249fa196d8259ff481f3b1476383f8f24e42 \ + --hash=sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe \ + --hash=sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda \ + --hash=sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e \ + --hash=sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737 \ + --hash=sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523 \ + --hash=sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591 \ + --hash=sha256:f71a396b3bf33ecaa1626c255855702aca4d3d9fea5e051b41ac59a9c1c41edc \ + --hash=sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a \ + --hash=sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50 + # via jinja2 +mkl==2025.3.0 \ + --hash=sha256:2dbf81b016150c2ce418d80707dcce11d0e3c56f20e1d54813174e7665405561 \ + --hash=sha256:7b81f5d2e034637b187ca58666878c4e8889988a78e39e0b6ee92e846568f660 + # via + # onemkl-sycl-blas + # onemkl-sycl-dft + # onemkl-sycl-lapack + # onemkl-sycl-rng + # onemkl-sycl-sparse + # torch +mpmath==1.3.0 \ + --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \ + --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c + # via sympy +msgpack==1.1.2 \ + --hash=sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2 \ + --hash=sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014 \ + --hash=sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931 \ + --hash=sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b \ + --hash=sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b \ + --hash=sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999 \ + --hash=sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029 \ + --hash=sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0 \ + --hash=sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9 \ + --hash=sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c \ + --hash=sha256:350ad5353a467d9e3b126d8d1b90fe05ad081e2e1cef5753f8c345217c37e7b8 \ + --hash=sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f \ + --hash=sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a \ + --hash=sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42 \ + --hash=sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e \ + --hash=sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f \ + --hash=sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7 \ + --hash=sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb \ + --hash=sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef \ + --hash=sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf \ + --hash=sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245 \ + --hash=sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794 \ + --hash=sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af \ + --hash=sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff \ + --hash=sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e \ + --hash=sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296 \ + --hash=sha256:67016ae8c8965124fdede9d3769528ad8284f14d635337ffa6a713a580f6c030 \ + --hash=sha256:6bde749afe671dc44893f8d08e83bf475a1a14570d67c4bb5cec5573463c8833 \ + --hash=sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939 \ + --hash=sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa \ + --hash=sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90 \ + --hash=sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c \ + --hash=sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717 \ + --hash=sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406 \ + --hash=sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a \ + --hash=sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251 \ + --hash=sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2 \ + --hash=sha256:94fd7dc7d8cb0a54432f296f2246bc39474e017204ca6f4ff345941d4ed285a7 \ + --hash=sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e \ + --hash=sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b \ + --hash=sha256:9fba231af7a933400238cb357ecccf8ab5d51535ea95d94fc35b7806218ff844 \ + --hash=sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9 \ + --hash=sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87 \ + --hash=sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b \ + --hash=sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c \ + --hash=sha256:a8f6e7d30253714751aa0b0c84ae28948e852ee7fb0524082e6716769124bc23 \ + --hash=sha256:ad09b984828d6b7bb52d1d1d0c9be68ad781fa004ca39216c8a1e63c0f34ba3c \ + --hash=sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e \ + --hash=sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620 \ + --hash=sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69 \ + --hash=sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f \ + --hash=sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68 \ + --hash=sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27 \ + --hash=sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46 \ + --hash=sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa \ + --hash=sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00 \ + --hash=sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9 \ + --hash=sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84 \ + --hash=sha256:ea5405c46e690122a76531ab97a079e184c0daf491e588592d6a23d3e32af99e \ + --hash=sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20 \ + --hash=sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e \ + --hash=sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162 + # via librosa +multidict==6.7.1 \ + --hash=sha256:026d264228bcd637d4e060844e39cdc60f86c479e463d49075dedc21b18fbbe0 \ + --hash=sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9 \ + --hash=sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581 \ + --hash=sha256:067343c68cd6612d375710f895337b3a98a033c94f14b9a99eff902f205424e2 \ + --hash=sha256:08ccb2a6dc72009093ebe7f3f073e5ec5964cba9a706fa94b1a1484039b87941 \ + --hash=sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3 \ + --hash=sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43 \ + --hash=sha256:0d17522c37d03e85c8098ec8431636309b2682cf12e58f4dbc76121fb50e4962 \ + --hash=sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1 \ + --hash=sha256:0e697826df7eb63418ee190fd06ce9f1803593bb4b9517d08c60d9b9a7f69d8f \ + --hash=sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c \ + --hash=sha256:121a34e5bfa410cdf2c8c49716de160de3b1dbcd86b49656f5681e4543bcd1a8 \ + --hash=sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa \ + --hash=sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6 \ + --hash=sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c \ + --hash=sha256:17207077e29342fdc2c9a82e4b306f1127bf1ea91f8b71e02d4798a70bb99991 \ + --hash=sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262 \ + --hash=sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd \ + --hash=sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d \ + --hash=sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d \ + --hash=sha256:1fa6609d0364f4f6f58351b4659a1f3e0e898ba2a8c5cac04cb2c7bc556b0bc5 \ + --hash=sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3 \ + --hash=sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601 \ + --hash=sha256:24c0cf81544ca5e17cfcb6e482e7a82cd475925242b308b890c9452a074d4505 \ + --hash=sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0 \ + --hash=sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292 \ + --hash=sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed \ + --hash=sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362 \ + --hash=sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511 \ + --hash=sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23 \ + --hash=sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2 \ + --hash=sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb \ + --hash=sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e \ + --hash=sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582 \ + --hash=sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0 \ + --hash=sha256:3943debf0fbb57bdde5901695c11094a9a36723e5c03875f87718ee15ca2f4d2 \ + --hash=sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e \ + --hash=sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d \ + --hash=sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65 \ + --hash=sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a \ + --hash=sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd \ + --hash=sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d \ + --hash=sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108 \ + --hash=sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177 \ + --hash=sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144 \ + --hash=sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5 \ + --hash=sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd \ + --hash=sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5 \ + --hash=sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060 \ + --hash=sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37 \ + --hash=sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56 \ + --hash=sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df \ + --hash=sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963 \ + --hash=sha256:5884a04f4ff56c6120f6ccf703bdeb8b5079d808ba604d4d53aec0d55dc33568 \ + --hash=sha256:59bc83d3f66b41dac1e7460aac1d196edc70c9ba3094965c467715a70ecb46db \ + --hash=sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118 \ + --hash=sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84 \ + --hash=sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f \ + --hash=sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889 \ + --hash=sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71 \ + --hash=sha256:65573858d27cdeaca41893185677dc82395159aa28875a8867af66532d413a8f \ + --hash=sha256:6704fa2b7453b2fb121740555fa1ee20cd98c4d011120caf4d2b8d4e7c76eec0 \ + --hash=sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7 \ + --hash=sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048 \ + --hash=sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8 \ + --hash=sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49 \ + --hash=sha256:6f77ce314a29263e67adadc7e7c1bc699fcb3a305059ab973d038f87caa42ed0 \ + --hash=sha256:749aa54f578f2e5f439538706a475aa844bfa8ef75854b1401e6e528e4937cf9 \ + --hash=sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59 \ + --hash=sha256:7dfb78d966b2c906ae1d28ccf6e6712a3cd04407ee5088cd276fe8cb42186190 \ + --hash=sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709 \ + --hash=sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d \ + --hash=sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c \ + --hash=sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e \ + --hash=sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2 \ + --hash=sha256:8affcf1c98b82bc901702eb73b6947a1bfa170823c153fe8a47b5f5f02e48e40 \ + --hash=sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3 \ + --hash=sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee \ + --hash=sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609 \ + --hash=sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c \ + --hash=sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445 \ + --hash=sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1 \ + --hash=sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a \ + --hash=sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5 \ + --hash=sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31 \ + --hash=sha256:974e72a2474600827abaeda71af0c53d9ebbc3c2eb7da37b37d7829ae31232d8 \ + --hash=sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33 \ + --hash=sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7 \ + --hash=sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca \ + --hash=sha256:98c5787b0a0d9a41d9311eae44c3b76e6753def8d8870ab501320efe75a6a5f8 \ + --hash=sha256:9b0d9b91d1aa44db9c1f1ecd0d9d2ae610b2f4f856448664e01a3b35899f3f92 \ + --hash=sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733 \ + --hash=sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429 \ + --hash=sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9 \ + --hash=sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4 \ + --hash=sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6 \ + --hash=sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2 \ + --hash=sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172 \ + --hash=sha256:a9fc4caa29e2e6ae408d1c450ac8bf19892c5fca83ee634ecd88a53332c59981 \ + --hash=sha256:aa23b001d968faef416ff70dc0f1ab045517b9b42a90edd3e9bcdb06479e31d5 \ + --hash=sha256:ac1c665bad8b5d762f5f85ebe4d94130c26965f11de70c708c75671297c776de \ + --hash=sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52 \ + --hash=sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7 \ + --hash=sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c \ + --hash=sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2 \ + --hash=sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6 \ + --hash=sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf \ + --hash=sha256:bb08271280173720e9fea9ede98e5231defcbad90f1624bea26f32ec8a956e2f \ + --hash=sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b \ + --hash=sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961 \ + --hash=sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a \ + --hash=sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3 \ + --hash=sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b \ + --hash=sha256:c524c6fb8fc342793708ab111c4dbc90ff9abd568de220432500e47e990c0358 \ + --hash=sha256:c5f0c21549ab432b57dcc82130f388d84ad8179824cc3f223d5e7cfbfd4143f6 \ + --hash=sha256:c6b3228e1d80af737b72925ce5fb4daf5a335e49cd7ab77ed7b9fdfbf58c526e \ + --hash=sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1 \ + --hash=sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c \ + --hash=sha256:c93c3db7ea657dd4637d57e74ab73de31bccefe144d3d4ce370052035bc85fb5 \ + --hash=sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53 \ + --hash=sha256:cdea2e7b2456cfb6694fb113066fd0ec7ea4d67e3a35e1f4cbeea0b448bf5872 \ + --hash=sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e \ + --hash=sha256:cf37cbe5ced48d417ba045aca1b21bafca67489452debcde94778a576666a1df \ + --hash=sha256:d4f49cb5661344764e4c7c7973e92a47a59b8fc19b6523649ec9dc4960e58a03 \ + --hash=sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8 \ + --hash=sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a \ + --hash=sha256:d82dd730a95e6643802f4454b8fdecdf08667881a9c5670db85bc5a56693f122 \ + --hash=sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a \ + --hash=sha256:dd96c01a9dcd4889dcfcf9eb5544ca0c77603f239e3ffab0524ec17aea9a93ee \ + --hash=sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32 \ + --hash=sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3 \ + --hash=sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489 \ + --hash=sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23 \ + --hash=sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34 \ + --hash=sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75 \ + --hash=sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8 \ + --hash=sha256:eb351f72c26dc9abe338ca7294661aa22969ad8ffe7ef7d5541d19f368dc854a \ + --hash=sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d \ + --hash=sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855 \ + --hash=sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b \ + --hash=sha256:f537b55778cd3cbee430abe3131255d3a78202e0f9ea7ffc6ada893a4bcaeea4 \ + --hash=sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4 \ + --hash=sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d \ + --hash=sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0 \ + --hash=sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba \ + --hash=sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19 + # via + # aiohttp + # yarl +nest-asyncio==1.6.0 \ + --hash=sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe \ + --hash=sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c + # via -r deps/requirements_xpu.txt +networkx==3.6.1 \ + --hash=sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509 \ + --hash=sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762 + # via torch +numba==0.61.2 \ + --hash=sha256:34fba9406078bac7ab052efbf0d13939426c753ad72946baaa5bf9ae0ebb8dd2 \ + --hash=sha256:3945615cd73c2c7eba2a85ccc9c1730c21cd3958bfcf5a44302abae0fb07bb60 \ + --hash=sha256:3a10a8fc9afac40b1eac55717cece1b8b1ac0b946f5065c89e00bde646b5b154 \ + --hash=sha256:48a53a3de8f8793526cbe330f2a39fe9a6638efcbf11bd63f3d2f9757ae345cd \ + --hash=sha256:49c980e4171948ffebf6b9a2520ea81feed113c1f4890747ba7f59e74be84b1b \ + --hash=sha256:4ddce10009bc097b080fc96876d14c051cc0c7679e99de3e0af59014dab7dfe8 \ + --hash=sha256:59321215e2e0ac5fa928a8020ab00b8e57cda8a97384963ac0dfa4d4e6aa54e7 \ + --hash=sha256:5b1bb509d01f23d70325d3a5a0e237cbc9544dd50e50588bc581ba860c213546 \ + --hash=sha256:5f154aaea625fb32cfbe3b80c5456d514d416fcdf79733dd69c0df3a11348e9e \ + --hash=sha256:76bcec9f46259cedf888041b9886e257ae101c6268261b19fda8cfbc52bec9d1 \ + --hash=sha256:7d3bcada3c9afba3bed413fba45845f2fb9cd0d2b27dd58a1be90257e293d140 \ + --hash=sha256:8750ee147940a6637b80ecf7f95062185ad8726c8c28a2295b8ec1160a196f7d \ + --hash=sha256:97cf4f12c728cf77c9c1d7c23707e4d8fb4632b46275f8f3397de33e5877af18 \ + --hash=sha256:ae45830b129c6137294093b269ef0a22998ccc27bf7cf096ab8dcf7bca8946f9 \ + --hash=sha256:ae8c7a522c26215d5f62ebec436e3d341f7f590079245a2f1008dfd498cc1642 \ + --hash=sha256:bbfdf4eca202cebade0b7d43896978e146f39398909a42941c9303f82f403a18 \ + --hash=sha256:bd1e74609855aa43661edffca37346e4e8462f6903889917e9f41db40907daa2 \ + --hash=sha256:bdbca73ad81fa196bd53dc12e3aaf1564ae036e0c125f237c7644fe64a4928ab \ + --hash=sha256:cf9f9fc00d6eca0c23fc840817ce9f439b9f03c8f03d6246c0e7f0cb15b7162a \ + --hash=sha256:ea0247617edcb5dd61f6106a56255baab031acc4257bddaeddb3a1003b4ca3fd \ + --hash=sha256:efd3db391df53aaa5cfbee189b6c910a5b471488749fd6606c3f33fc984c2ae2 + # via librosa +numpy==1.26.4 \ + --hash=sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b \ + --hash=sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818 \ + --hash=sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20 \ + --hash=sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0 \ + --hash=sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010 \ + --hash=sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a \ + --hash=sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea \ + --hash=sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c \ + --hash=sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71 \ + --hash=sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110 \ + --hash=sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be \ + --hash=sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a \ + --hash=sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a \ + --hash=sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5 \ + --hash=sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed \ + --hash=sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd \ + --hash=sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c \ + --hash=sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e \ + --hash=sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0 \ + --hash=sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c \ + --hash=sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a \ + --hash=sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b \ + --hash=sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0 \ + --hash=sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6 \ + --hash=sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2 \ + --hash=sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a \ + --hash=sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30 \ + --hash=sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218 \ + --hash=sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5 \ + --hash=sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07 \ + --hash=sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2 \ + --hash=sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4 \ + --hash=sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764 \ + --hash=sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef \ + --hash=sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3 \ + --hash=sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f + # via + # -r deps/requirements_xpu.txt + # librosa + # numba + # scikit-learn + # scipy + # sentence-transformers + # soundfile + # soxr + # torchvision + # transformers +oneccl==2021.17.1 \ + --hash=sha256:c77b16a1686d252ece7df331da8e4feeb3776c40bdd03a8f8e9942ad378d8ff8 + # via + # oneccl-devel + # torch +oneccl-devel==2021.17.1 \ + --hash=sha256:c3f7438f12b9763dd2bcb3ce4f48b2462788534947545a68117f503b9ab01d2a + # via torch +onemkl-license==2025.3.0 \ + --hash=sha256:35a179620bcadbcc3d17d74f7f72cab75889f3736b89685f6a68158325b65e91 \ + --hash=sha256:a810b25bb24a90db4492d81c71cde13183d8951ce26960d6dc56d4f4e3dc95ff + # via + # mkl + # torch +onemkl-sycl-blas==2025.3.0 \ + --hash=sha256:e594c19b43e5d0bc496352d2111851b5e722c08047f16841dfdcc7e0a36c1d63 \ + --hash=sha256:e7bb5f28afc045fcbbd898914f477d7e7535ec9fb45bb946ed9f817bd1ef1f5b + # via + # onemkl-sycl-lapack + # onemkl-sycl-sparse + # torch +onemkl-sycl-dft==2025.3.0 \ + --hash=sha256:28347c15c737f131d4d261adb65cee7eb11d8a55d225ba1e8c99cfc24c040fd3 \ + --hash=sha256:3ae23f3820f0651c8b43cff646ddd24dac29382af6cb24bf46d5c8a472c8b899 + # via torch +onemkl-sycl-lapack==2025.3.0 \ + --hash=sha256:54ede6283cd2f0300c8ee5f97a3487c1cecab322493108b016ae057b3865e6ce \ + --hash=sha256:d2a4d7ba26b90ab33a2f64ed6c95c596c8721ee251983eaf9a4c9856d1e34c7b + # via torch +onemkl-sycl-rng==2025.3.0 \ + --hash=sha256:ae32b40d10a018e183a8e3a96df86842f92e75e08e5ded416aabdccb7e75919a \ + --hash=sha256:e440641b7c1a021c4975b95b99828b80155048d890ebfd24f34060feaa5b3375 + # via torch +onemkl-sycl-sparse==2025.3.0 \ + --hash=sha256:930cd2d14aae5a1bfec07fa10b817c444783453aa1a65540de46e0cbf9d00de6 \ + --hash=sha256:a3e200ec012ff66a5da08f516df6a02223b4e76fed1e1454865958889e9f64c8 + # via torch +openai==2.29.0 \ + --hash=sha256:32d09eb2f661b38d3edd7d7e1a2943d1633f572596febe64c0cd370c86d52bec \ + --hash=sha256:b7c5de513c3286d17c5e29b92c4c98ceaf0d775244ac8159aeb1bddf840eb42a + # via -r deps/requirements_xpu.txt +orjson==3.11.8 \ + --hash=sha256:0022bb50f90da04b009ce32c512dc1885910daa7cb10b7b0cba4505b16db82a8 \ + --hash=sha256:003646067cc48b7fcab2ae0c562491c9b5d2cbd43f1e5f16d98fd118c5522d34 \ + --hash=sha256:01928d0476b216ad2201823b0a74000440360cef4fed1912d297b8d84718f277 \ + --hash=sha256:01c4e5a6695dc09098f2e6468a251bc4671c50922d4d745aff1a0a33a0cf5b8d \ + --hash=sha256:093d489fa039ddade2db541097dbb484999fcc65fc2b0ff9819141e2ab364f25 \ + --hash=sha256:0b57f67710a8cd459e4e54eb96d5f77f3624eba0c661ba19a525807e42eccade \ + --hash=sha256:0e32f7154299f42ae66f13488963269e5eccb8d588a65bc839ed986919fc9fac \ + --hash=sha256:14439063aebcb92401c11afc68ee4e407258d2752e62d748b6942dad20d2a70d \ + --hash=sha256:14778ffd0f6896aa613951a7fbf4690229aa7a543cb2bfbe9f358e08aafa9546 \ + --hash=sha256:14f7b8fcb35ef403b42fa5ecfa4ed032332a91f3dc7368fbce4184d59e1eae0d \ + --hash=sha256:1ab359aff0436d80bfe8a23b46b5fea69f1e18aaf1760a709b4787f1318b317f \ + --hash=sha256:1cd0b77e77c95758f8e1100139844e99f3ccc87e71e6fc8e1c027e55807c549f \ + --hash=sha256:25e0c672a2e32348d2eb33057b41e754091f2835f87222e4675b796b92264f06 \ + --hash=sha256:29c009e7a2ca9ad0ed1376ce20dd692146a5d9fe4310848904b6b4fee5c5c137 \ + --hash=sha256:3222adff1e1ff0dce93c16146b93063a7793de6c43d52309ae321234cdaf0f4d \ + --hash=sha256:3223665349bbfb68da234acd9846955b1a0808cbe5520ff634bf253a4407009b \ + --hash=sha256:3cf17c141617b88ced4536b2135c552490f07799f6ad565948ea07bef0dcb9a6 \ + --hash=sha256:3f23426851d98478c8970da5991f84784a76682213cd50eb73a1da56b95239dc \ + --hash=sha256:3f262401086a3960586af06c054609365e98407151f5ea24a62893a40d80dbbb \ + --hash=sha256:436c4922968a619fb7fef1ccd4b8b3a76c13b67d607073914d675026e911a65c \ + --hash=sha256:469ac2125611b7c5741a0b3798cd9e5786cbad6345f9f400c77212be89563bec \ + --hash=sha256:4861bde57f4d253ab041e374f44023460e60e71efaa121f3c5f0ed457c3a701e \ + --hash=sha256:48854463b0572cc87dac7d981aa72ed8bf6deedc0511853dc76b8bbd5482d36d \ + --hash=sha256:53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f \ + --hash=sha256:54153d21520a71a4c82a0dbb4523e468941d549d221dc173de0f019678cf3813 \ + --hash=sha256:55120759e61309af7fcf9e961c6f6af3dde5921cdb3ee863ef63fd9db126cae6 \ + --hash=sha256:5774c1fdcc98b2259800b683b19599c133baeb11d60033e2095fd9d4667b82db \ + --hash=sha256:58a4a208a6fbfdb7a7327b8f201c6014f189f721fd55d047cafc4157af1bc62a \ + --hash=sha256:58fb9b17b4472c7b1dcf1a54583629e62e23779b2331052f09a9249edf81675b \ + --hash=sha256:5d8b5231de76c528a46b57010bbd83fb51e056aa0220a372fd5065e978406f1c \ + --hash=sha256:5f8952d6d2505c003e8f0224ff7858d341fa4e33fef82b91c4ff0ef070f2393c \ + --hash=sha256:61c9d357a59465736022d5d9ba06687afb7611dfb581a9d2129b77a6fcf78e59 \ + --hash=sha256:6a3d159d5ffa0e3961f353c4b036540996bf8b9697ccc38261c0eac1fd3347a6 \ + --hash=sha256:6a4a639049c44d36a6d1ae0f4a94b271605c745aee5647fa8ffaabcdc01b69a6 \ + --hash=sha256:6ccdea2c213cf9f3d9490cbd5d427693c870753df41e6cb375bd79bcbafc8817 \ + --hash=sha256:6dbe9a97bdb4d8d9d5367b52a7c32549bba70b2739c58ef74a6964a6d05ae054 \ + --hash=sha256:6eda5b8b6be91d3f26efb7dc6e5e68ee805bc5617f65a328587b35255f138bf4 \ + --hash=sha256:705b895b781b3e395c067129d8551655642dfe9437273211d5404e87ac752b53 \ + --hash=sha256:708c95f925a43ab9f34625e45dcdadf09ec8a6e7b664a938f2f8d5650f6c090b \ + --hash=sha256:735e2262363dcbe05c35e3a8869898022af78f89dde9e256924dc02e99fe69ca \ + --hash=sha256:76070a76e9c5ae661e2d9848f216980d8d533e0f8143e6ed462807b242e3c5e8 \ + --hash=sha256:7679bc2f01bb0d219758f1a5f87bb7c8a81c0a186824a393b366876b4948e14f \ + --hash=sha256:88006eda83858a9fdf73985ce3804e885c2befb2f506c9a3723cdeb5a2880e3e \ + --hash=sha256:883206d55b1bd5f5679ad5e6ddd3d1a5e3cac5190482927fdb8c78fb699193b5 \ + --hash=sha256:8ac7381c83dd3d4a6347e6635950aa448f54e7b8406a27c7ecb4a37e9f1ae08b \ + --hash=sha256:8e8c6218b614badf8e229b697865df4301afa74b791b6c9ade01d19a9953a942 \ + --hash=sha256:9185589c1f2a944c17e26c9925dcdbc2df061cc4a145395c57f0c51f9b5dbfcd \ + --hash=sha256:93de06bc920854552493c81f1f729fab7213b7db4b8195355db5fda02c7d1363 \ + --hash=sha256:96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e \ + --hash=sha256:97c8f5d3b62380b70c36ffacb2a356b7c6becec86099b177f73851ba095ef623 \ + --hash=sha256:97d823831105c01f6c8029faf297633dbeb30271892bd430e9c24ceae3734744 \ + --hash=sha256:98bdc6cb889d19bed01de46e67574a2eab61f5cc6b768ed50e8ac68e9d6ffab6 \ + --hash=sha256:9b48e274f8824567d74e2158199e269597edf00823a1b12b63d48462bbf5123e \ + --hash=sha256:a5c370674ebabe16c6ccac33ff80c62bf8a6e59439f5e9d40c1f5ab8fd2215b7 \ + --hash=sha256:b43dc2a391981d36c42fa57747a49dae793ef1d2e43898b197925b5534abd10a \ + --hash=sha256:c154a35dd1330707450bb4d4e7dd1f17fa6f42267a40c1e8a1daa5e13719b4b8 \ + --hash=sha256:c2bdf7b2facc80b5e34f48a2d557727d5c5c57a8a450de122ae81fa26a81c1bc \ + --hash=sha256:c492a0e011c0f9066e9ceaa896fbc5b068c54d365fea5f3444b697ee01bc8625 \ + --hash=sha256:c60c0423f15abb6cf78f56dff00168a1b582f7a1c23f114036e2bfc697814d5f \ + --hash=sha256:c98121237fea2f679480765abd566f7713185897f35c9e6c2add7e3a9900eb61 \ + --hash=sha256:ccd7ba1b0605813a0715171d39ec4c314cb97a9c85893c2c5c0c3a3729df38bf \ + --hash=sha256:cdbc8c9c02463fef4d3c53a9ba3336d05496ec8e1f1c53326a1e4acc11f5c600 \ + --hash=sha256:e0950ed1bcb9893f4293fd5c5a7ee10934fbf82c4101c70be360db23ce24b7d2 \ + --hash=sha256:e6693ff90018600c72fd18d3d22fa438be26076cd3c823da5f63f7bab28c11cb \ + --hash=sha256:ea56a955056a6d6c550cf18b3348656a9d9a4f02e2d0c02cabf3c73f1055d506 \ + --hash=sha256:ebaed4cef74a045b83e23537b52ef19a367c7e3f536751e355a2a394f8648559 \ + --hash=sha256:ec795530a73c269a55130498842aaa762e4a939f6ce481a7e986eeaa790e9da4 \ + --hash=sha256:ed193ce51d77a3830cad399a529cd4ef029968761f43ddc549e1bc62b40d88f8 \ + --hash=sha256:ee8db7bfb6fe03581bbab54d7c4124a6dd6a7f4273a38f7267197890f094675f \ + --hash=sha256:f30491bc4f862aa15744b9738517454f1e46e56c972a2be87d70d727d5b2a8f8 \ + --hash=sha256:f89b6d0b3a8d81e1929d3ab3d92bbc225688bd80a770c49432543928fe09ac55 \ + --hash=sha256:fa72e71977bff96567b0f500fc5bfd2fdf915f34052c782a4c6ebbdaa97aa858 \ + --hash=sha256:fe0b8c83e0f36247fc9431ce5425a5d95f9b3a689133d494831bdbd6f0bceb13 \ + --hash=sha256:ff51f9d657d1afb6f410cb435792ce4e1fe427aab23d2fcd727a2876e21d4cb6 + # via -r deps/requirements_xpu.txt +oss2==2.19.1 \ + --hash=sha256:a8ab9ee7eb99e88a7e1382edc6ea641d219d585a7e074e3776e9dec9473e59c1 + # via -r deps/requirements_xpu.txt +packaging==26.0 \ + --hash=sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4 \ + --hash=sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529 + # via + # huggingface-hub + # lazy-loader + # pooch + # transformers +partial-json-parser==0.2.1.1.post7 \ + --hash=sha256:145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae \ + --hash=sha256:86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922 + # via -r deps/requirements_xpu.txt +pillow==12.1.1 \ + --hash=sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9 \ + --hash=sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da \ + --hash=sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f \ + --hash=sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642 \ + --hash=sha256:178aa072084bd88ec759052feca8e56cbb14a60b39322b99a049e58090479713 \ + --hash=sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850 \ + --hash=sha256:1a9b0ee305220b392e1124a764ee4265bd063e54a751a6b62eff69992f457fa9 \ + --hash=sha256:1f1625b72740fdda5d77b4def688eb8fd6490975d06b909fd19f13f391e077e0 \ + --hash=sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9 \ + --hash=sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8 \ + --hash=sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6 \ + --hash=sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd \ + --hash=sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5 \ + --hash=sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c \ + --hash=sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35 \ + --hash=sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1 \ + --hash=sha256:36341d06738a9f66c8287cf8b876d24b18db9bd8740fa0672c74e259ad408cff \ + --hash=sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38 \ + --hash=sha256:3a5cbdcddad0af3da87cb16b60d23648bc3b51967eb07223e9fed77a82b457c4 \ + --hash=sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af \ + --hash=sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60 \ + --hash=sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986 \ + --hash=sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13 \ + --hash=sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717 \ + --hash=sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e \ + --hash=sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b \ + --hash=sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15 \ + --hash=sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a \ + --hash=sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb \ + --hash=sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d \ + --hash=sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b \ + --hash=sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e \ + --hash=sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a \ + --hash=sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f \ + --hash=sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a \ + --hash=sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce \ + --hash=sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc \ + --hash=sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f \ + --hash=sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586 \ + --hash=sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f \ + --hash=sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9 \ + --hash=sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8 \ + --hash=sha256:6c52f062424c523d6c4db85518774cc3d50f5539dd6eed32b8f6229b26f24d40 \ + --hash=sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60 \ + --hash=sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c \ + --hash=sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0 \ + --hash=sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334 \ + --hash=sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af \ + --hash=sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735 \ + --hash=sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524 \ + --hash=sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf \ + --hash=sha256:89c7e895002bbe49cdc5426150377cbbc04767d7547ed145473f496dfa40408b \ + --hash=sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2 \ + --hash=sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9 \ + --hash=sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7 \ + --hash=sha256:99c1506ea77c11531d75e3a412832a13a71c7ebc8192ab9e4b2e355555920e3e \ + --hash=sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4 \ + --hash=sha256:9f51079765661884a486727f0729d29054242f74b46186026582b4e4769918e4 \ + --hash=sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b \ + --hash=sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397 \ + --hash=sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c \ + --hash=sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e \ + --hash=sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029 \ + --hash=sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3 \ + --hash=sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052 \ + --hash=sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984 \ + --hash=sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293 \ + --hash=sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523 \ + --hash=sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f \ + --hash=sha256:b66e95d05ba806247aaa1561f080abc7975daf715c30780ff92a20e4ec546e1b \ + --hash=sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80 \ + --hash=sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f \ + --hash=sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79 \ + --hash=sha256:c6008de247150668a705a6338156efb92334113421ceecf7438a12c9a12dab23 \ + --hash=sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8 \ + --hash=sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e \ + --hash=sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3 \ + --hash=sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e \ + --hash=sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36 \ + --hash=sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f \ + --hash=sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5 \ + --hash=sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f \ + --hash=sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6 \ + --hash=sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32 \ + --hash=sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20 \ + --hash=sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202 \ + --hash=sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0 \ + --hash=sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3 \ + --hash=sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563 \ + --hash=sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090 \ + --hash=sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289 + # via + # -r deps/requirements_xpu.txt + # pillow-heif + # sentence-transformers + # torchvision +pillow-avif-plugin==1.5.5 \ + --hash=sha256:00053c630c65d7634a5ac9f42f6981275aed60c4fc41fc5afe9e63178c69f281 \ + --hash=sha256:0a569a81287d141b6d3b8652663eac18403dfcc1662bb2e9f8f11afa3b956d13 \ + --hash=sha256:0ac4ce64b66b0b6eb96484b6a9985d06f56a4b57f357f6cd1d040543f6bedf1a \ + --hash=sha256:0b04eac3d9f13f3fb1f147dbc39a54c186d16b8696b2b984880d01803995dbd5 \ + --hash=sha256:105a6f4177ce3fcdacc70c8771f4003f3c85e8ba749ee7e76ecb6f04c5e78a8c \ + --hash=sha256:1831d3d75671e1c0a936ffceb98bc9fb52972088de7e4f7ec8ffb4478e241f62 \ + --hash=sha256:1bc75fe3ce1f369bb5068911625fca1430c63b62ae8d8c1ae85e4c839b4dd23c \ + --hash=sha256:1d3d48e5d3468be246fdff58e711ad0dcba5c7d6730006bab8b9c53d7dc4bddf \ + --hash=sha256:2026acc9697b64adaa328b7e8504b579d30e45f46656953a8421aafa7b6f9b33 \ + --hash=sha256:21a195e96e72ba7de32a6a1c9123702508fd859b2eff02bae3ddd3aa1ee3ad4a \ + --hash=sha256:2252182b406327dfb94e0406f8d0b5f45b4eb921e42f1574555d094359f47f86 \ + --hash=sha256:25b843855bd7f51d64def876d570836432576ccb10926744cef6e7b2bf851bea \ + --hash=sha256:283d2850b2f9ceb6492a6b77ef97fcb07242a31951c61134df0817f6deb29aea \ + --hash=sha256:2d8cfb586ffa960894cc29f8b1d535544bb29db99897ec0db076e36a159564a5 \ + --hash=sha256:32fee45879455d3bcb9c6ea75f6fbd1553d2289785f3416ead11c084d394b575 \ + --hash=sha256:3334781643766fec977c8bfa606147f53589cd082eb72c57d888c0d3af0aa543 \ + --hash=sha256:3929e930b60c8d28c595f118386d441c3507b7b764d86aa60a395be7ad0f66e8 \ + --hash=sha256:3c2c7ffff57675240ca0aed8f3050bc58409f8656274a1caa24d41157b98ba3b \ + --hash=sha256:3ec51ff05f6d254b3d2ec2fd134040921959554b542a5f1dbb62ee49c29e51ed \ + --hash=sha256:41f91f044c34adf7b22e0e39fcdc5281df8894d1d694da09f4fc1551d2699dc2 \ + --hash=sha256:465f2aa24ed03d4ad5545ab4cd7627074c181cc0e96715419cd6c8fcff509779 \ + --hash=sha256:5315a126e3a29ae4d1750d0dca583cb5d0acb5f8ec6a36b57936dd5aa2f813e9 \ + --hash=sha256:5735b1373faaa890a77b91971afcc60b14cbeab3960630a76011ebdb3e6d5fe6 \ + --hash=sha256:5b505c34d8e1da3bb80ff5a386f6b193ca5f9275515047ad3c7d473ab28de6cb \ + --hash=sha256:5c6c3d0d617aed5ec3c1ec1219c55538da67d9ebdf587bd62b0a35fb3626dc56 \ + --hash=sha256:5e2d39f9c4400e810c951b3d1d4310142fb3af43134a07c995ab1f7275b82b5e \ + --hash=sha256:639d38d29f43c39141005693e850d08238dc5b7090e0a933990f52800688b0d7 \ + --hash=sha256:68a79c18ac12dfee00397d749629f1beec0d7a7bff836e410301ab53c10e685a \ + --hash=sha256:6c39a5abe3316551329c998ea14b24034f0e8a150c10b590121367a807e47c5e \ + --hash=sha256:6e98edb1ce487898668c93599fbb004fab68ad9d48cef11dab3675c5960fef95 \ + --hash=sha256:705ddd136f03b681f5be28e72798204c957658c240d2a874d8656efecdf82b75 \ + --hash=sha256:73d37914ad82bec6583c5df70dea5ccb4d2f5435ca3c48e50b1c5fff52c92d6e \ + --hash=sha256:7524b9d0757a1ff4ed1337188d690b68949e3f521e02246b1469d49449294080 \ + --hash=sha256:787027f3cbb821627c36398b2a6c4b4c97de500e8ba966203de58e4e17943693 \ + --hash=sha256:7d3e56a596421a3af7970cf1a64767dc9fc76dc7b364b36919eb75b8b5ec5fcd \ + --hash=sha256:81db79f197a9abe0381f005045380388d01458f8b20d69b09b2259f0efaeb5e3 \ + --hash=sha256:865902db0b4008bdd78004bb69aab796b1101e04e6175a83577042037485bf85 \ + --hash=sha256:8a4714976dfcd24ce254e36c3da67ae4240ffbeb9c223d90fae6cd1feaa8030d \ + --hash=sha256:8cf37478dd240d56d95e2a612aeea838d9cb3fddc0f6c5cbf63d1651b2e80b8f \ + --hash=sha256:8f252620a6f96cb127a509df42a304500e2aaec8ced103d448504a1e17439bcb \ + --hash=sha256:905b57c6b4ea323cf6731b8f8ee0d4bcc01847612c80b5fde8f9240cf3d06c75 \ + --hash=sha256:9353488cb02a59b106f36a167897ba568767a4eca0622d9d1255fe6b8d223a68 \ + --hash=sha256:9441006c3d242dfb7b54e9294a747b578f620446998a2384cfd2926cc0c0d107 \ + --hash=sha256:9814c13ebdbf73cec42db8646d717ca705e50d8994ab9ab42dfaa8a55d6206e9 \ + --hash=sha256:9893395d7fe2f46b500b4c2766df4721a569bfb9fd7a2e79658ab71e9c56847b \ + --hash=sha256:99541ef2cd697ff071a9633cbf6e501589dc7ee34607b326a8afc3fc632915c0 \ + --hash=sha256:99dbc6483edd40fd5aae71cd63169e7be8dd891ba8534a22cc33c1e97919f779 \ + --hash=sha256:9a1f9048de29827280630d879e184ef07424d92afe9c6b37f4c1d82670a2a00f \ + --hash=sha256:a34e3f3fe6b50114fa24b001b73644b48f2953cc16522c4703790766d2ef5bc3 \ + --hash=sha256:a6c6c70dc227d2810ae1e51e39e6f1adccd310a284e1f788aeb54a52fb95c05b \ + --hash=sha256:a7bafcc8579f1ab1e8ec3f9d249528399fa50c563381e52bcf56dba797b957a3 \ + --hash=sha256:a9e9d630c43773ccb3300310b97985c26117679ec5d8c9645f458538280a51a1 \ + --hash=sha256:aa82bb5f0080ae6827b4cd0a93c906cb77c0958431ed73e3b12b1f8d1ed66d0a \ + --hash=sha256:b4012226dcac34f4e4ed35ed367463f8565e5f67982a9d375a39a9c377265707 \ + --hash=sha256:b7b596ccb0be5289ab320be6b5dc777b2c09b0ede07cc353735232cc4c73f428 \ + --hash=sha256:b9ff99e112bcb54c78481223d476941c3638eda8a243d460d62f72aed2381182 \ + --hash=sha256:bbd18def950386cab6383054d8858b73fc239ddfe8a5c54ca9cefbe07760fb60 \ + --hash=sha256:c0abc4b7406d23c386bfeda9620e4c9bd54b65ccb85b42dba82c6b08aedf99d7 \ + --hash=sha256:c10aaa7dd62a5f96abf1383c899a0a1e719bf3e3d64d62911694799028804717 \ + --hash=sha256:c259e75cb8ab93b64f2689a580653b20acc48ff393a5aad7731f00a06ad987b1 \ + --hash=sha256:c98ce14366b5f55272b44de22886e1d398ce33448536d0fd31224665291f8e13 \ + --hash=sha256:cf462e4f1463a942a77f7222b8bc4d51f0580aed49cedb36c7cfe35028a9f67b \ + --hash=sha256:cff2d641b86a72c6767f19f0c5fdab54289d1fa9457bcacb19c030b620ca461e \ + --hash=sha256:d3f7d124f6bc1c63608e11c7846b07357f38c3819eddb0d24476992a1cbfee07 \ + --hash=sha256:d410c8f7a8f570f93cbbeffcde22574cbf57bc8e5de8ccc973530a74f1aaeee2 \ + --hash=sha256:d9df42d4b81e8d3d367d392305f45282cfc17d523348e3b38ba79744caf6bd5b \ + --hash=sha256:dc277004ea675f629ac51155275f69bb18b0b7bf3ed46a788fc4a70f79b8e2bf \ + --hash=sha256:e3c85a268297bf9de04848ef22003c6d6a9b715a196f467de65c3c92315c60e9 \ + --hash=sha256:e45fbda332affe999c250de21f4aca277b3fe6805c8fce182006e854e6b4de5c \ + --hash=sha256:e60851ea25d0674650416c915377078120f078714b708aa40492765768f7595e \ + --hash=sha256:e69411edfcd17907038c00a46c7e2ebc2c10f14895e23a853909c34ee66ffbda \ + --hash=sha256:e7bd1199004c61e820ef6d6bf21ab2bf76d6daea7893fe8fb06f2ddc146dfe48 \ + --hash=sha256:e97956a62fc4f252e2a54644312839e194ec09b693f2f7b4d28c44cd747baf9d \ + --hash=sha256:ed1253bad7a2924164a078341a98384ba1aed08d9d25b59b957438fcac1ac26a \ + --hash=sha256:f000cc51d07d6f47a5b0b2c7f4be0d82af0e1150dcb6361ce8e8973240e8c53a \ + --hash=sha256:f102dec7f482b5ca999a923933e440a82bfd8ae2eb5893fe144ef8f47cf8d971 \ + --hash=sha256:f3bffa2f01b3bac6cfebc47a1977344f1ab1400aaa78af437ab73ff1a6f865b4 \ + --hash=sha256:f83a25ef3131a3f1f01966b2291eb0cc387caf6d9021510fdc65f895e8528897 \ + --hash=sha256:f91f8771393653d71df487022c092cb62149a3b52caea2fc6f56ebd341bc3042 \ + --hash=sha256:f9f677a1085c91a95e96bbcbfdeb93337049a6c5956b379663901e9c85f6f830 \ + --hash=sha256:f9fd65cbb9907be3649423d6a54a7678a41bde1d8ef3a849001f844211447690 \ + --hash=sha256:fd527c6225d7e1c14ebb628dcdabce190dcceb46b7d9297ab0a5b5066cf3e7eb \ + --hash=sha256:fe3d66eceae96094b39b3b5d7643d310ce59680f2138da59742582054830c882 + # via -r deps/requirements_xpu.txt +pillow-heif==1.3.0 \ + --hash=sha256:05149bd26b08dae5af7a389af6db13cef4f12c7871db73d84e40a1f3c83b0142 \ + --hash=sha256:079abbcaeb42ef0849a33f35c1a96ccd431feb56b242a0d4f8435a1c8ca02c7d \ + --hash=sha256:09a924fbb505674546973518b8906f499a56bb3332752a144bc272becd59c141 \ + --hash=sha256:0addc7d25133a2abd0149d1f1b8063808268c9ed75dc228c2196c90d56639a25 \ + --hash=sha256:0b69cc05b4f22ac57f1fd8f5f7ae96ae7c752036659ea975ec5f5565efadd87f \ + --hash=sha256:0ea3a4b2de4b6c63407af72afdac901616807c6e6a030fe77851d227bca3727a \ + --hash=sha256:142b307de087eba33d3174aa29a9669b65a7d006192ef8c98579920be3b56f64 \ + --hash=sha256:17ecbbadfe10ea12a65c1c12354dc1ed8ae1e5d1b7092ea753641b029f7d6f9e \ + --hash=sha256:18c7c35a9d98ed9eaaf2db601ee43425ebccc698801df9c008aa04e00756a22e \ + --hash=sha256:1a59db0091556d11ab26c2b34532b7992965520027ba0a64084771bcc9a31156 \ + --hash=sha256:2723c4b85c5ad0420cb0b3e512ac0aa015e3c8b13013b4738816833aa431f919 \ + --hash=sha256:33b838d06e2fd730f806af5a76bfc4cd3de9d146d88d37572e40f7a4c4ff8221 \ + --hash=sha256:36bbea7679467caa3a154db11c04f1ca2fa8591e886f06f40f7831c14b58d771 \ + --hash=sha256:4c4eef69c7caec0f41af13308bba5883bde751119f27a51c9a299b83852f3430 \ + --hash=sha256:54404c9b6f0323114527579f54cc966b47206f99d943e47d73e1091ab0b9d2ba \ + --hash=sha256:5d433048bd23436afa2a33e08fc622712ec97fea1c230d5b5a0fafd5512628c8 \ + --hash=sha256:5f0db0bf49162fb1d73d13340a9576b3a2805bde026a9a40038bcc1a0878d710 \ + --hash=sha256:625b67f7000b3aae645e4aea4170a6f0bb9015577c69cf249c360b10e071e8a7 \ + --hash=sha256:633f5d7fbf60a489ba301fbba06e75539a5cd22ff0b036162db2167803416470 \ + --hash=sha256:641c50a064aa9ad6626a6b2b914b65855202f937d573d53838e344feb2e8c6d1 \ + --hash=sha256:65c5d05cb7f5e1eadbe9c605ae3a4dd3ef953adb33e7d809d5fb56f8a6753588 \ + --hash=sha256:68bea3b9396fdd6c711e66fc645df92bbe53d48892909192ce9a30e4c619878a \ + --hash=sha256:6bdb197b43a629e2118fd33a9ebcf39abdabe5540b80d8862c53a7611edb42ab \ + --hash=sha256:6d3cdc335df30652ae9b07438e9898ce5cb5dbc47012fa14f93be1df9d446dc5 \ + --hash=sha256:6e8444ccb330015e1db930207d269886e4b6c666121cd9e5fdad88735950b09f \ + --hash=sha256:71f88d180547bb5112b56310c8c5e338d8358320a402c80afabc6b2f39eadddb \ + --hash=sha256:76c33f80ec111492642b98309db98516a7fba9677dcda9ec5fe9111b7e38d720 \ + --hash=sha256:7cf893689132bec18f0c55a505da9ebf3a8feb33dd354fe2ac050f20f4f862e0 \ + --hash=sha256:7d30054ccc97ecbe5ee3fa486a505ccc33bfbb27f005ad624ddb4c17b80ddd57 \ + --hash=sha256:8267a73d3b2d07a47a96428bd8cd4c406e1637a94f29d4c16ce08b31b8e50a07 \ + --hash=sha256:84c3816742c2e49176e651895e73c555b9c3b0f3561d60230242f3be0c9d272b \ + --hash=sha256:9390dd7987887aa09779fbd88bbab715c732c9ad3a71d6707284035e3ca93379 \ + --hash=sha256:9acee893186bdde6140d30a7dc6d7c928e4ad3007989764f6e54a7a517faa332 \ + --hash=sha256:a25a58368222c388a96b111f4621423eac6fa07a0bbcb2ac5eaf624153cde04e \ + --hash=sha256:a5a9f26d9ece400f55ac006e2fed079392e44a550023c99122e281fcd72b7c06 \ + --hash=sha256:af8d2bda85e395677d5bb50d7bda3b5655c946cc95b913b5e7222fabacbb467f \ + --hash=sha256:b5a1458bc11ca83cd72ec4a93f739ad3ae4315ae66766022ec16d12993a863a4 \ + --hash=sha256:bdd6695d5be0d98ae0e9a5f88fe26f1a6eca0a5b6d43d0a92a97f89fea5842f7 \ + --hash=sha256:d00218ce66aa74cddb5cb64e59a8867ed6722cc430b240d578ef3bc1307998a3 \ + --hash=sha256:dc177fbdf598770cad4afa99c082a30b9d090e60c39656904338717803ae59b2 \ + --hash=sha256:dc1b9c9efdf8345d703118449ff69696d0827bdf28e3b52f82015f5714f7c23e \ + --hash=sha256:e031f0036200da349cdac1328a3617a9d13b7f9145355c0a36306ce3b9f1d622 \ + --hash=sha256:e557b7082e785ff4505b2be258409fc3983162a3802f5438aa3177201d0e5a41 \ + --hash=sha256:edb3ef437e8841475db14721f0529e600bb55c41b549ad1794a0831e28f33bac \ + --hash=sha256:ee26b2155721e7f5f7b10fa93ca2ad3be59547c5c5e5d9d50e6ea17531b81d60 \ + --hash=sha256:f8b7a50058fc3152f42b68aa2b30601249f61aa5c6c27876af076785c7051fd9 \ + --hash=sha256:f92b387af891cf5d98f52e79eeaf51ee7955a54fe2deeec12bfb7519e41464b5 \ + --hash=sha256:f9f73246836f93f99343cbc3052b61d212d27e59ddf40262d494a1e3e54af31a + # via -r deps/requirements_xpu.txt +platformdirs==4.9.4 \ + --hash=sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934 \ + --hash=sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868 + # via pooch +pooch==1.9.0 \ + --hash=sha256:de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed \ + --hash=sha256:f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b + # via librosa +portalocker==3.2.0 \ + --hash=sha256:1f3002956a54a8c3730586c5c77bf18fae4149e07eaf1c29fc3faf4d5a3f89ac \ + --hash=sha256:3cdc5f565312224bc570c49337bd21428bba0ef363bbcf58b9ef4a9f11779968 + # via + # -r deps/requirements_xpu.txt + # concurrent-log-handler +prettytable==3.17.0 \ + --hash=sha256:59f2590776527f3c9e8cf9fe7b66dd215837cca96a9c39567414cbc632e8ddb0 \ + --hash=sha256:aad69b294ddbe3e1f95ef8886a060ed1666a0b83018bbf56295f6f226c43d287 + # via -r deps/requirements_xpu.txt +propcache==0.4.1 \ + --hash=sha256:0002004213ee1f36cfb3f9a42b5066100c44276b9b72b4e1504cddd3d692e86e \ + --hash=sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4 \ + --hash=sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be \ + --hash=sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3 \ + --hash=sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85 \ + --hash=sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b \ + --hash=sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367 \ + --hash=sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf \ + --hash=sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393 \ + --hash=sha256:182b51b421f0501952d938dc0b0eb45246a5b5153c50d42b495ad5fb7517c888 \ + --hash=sha256:1cdb7988c4e5ac7f6d175a28a9aa0c94cb6f2ebe52756a3c0cda98d2809a9e37 \ + --hash=sha256:1eb2994229cc8ce7fe9b3db88f5465f5fd8651672840b2e426b88cdb1a30aac8 \ + --hash=sha256:1f0978529a418ebd1f49dad413a2b68af33f85d5c5ca5c6ca2a3bed375a7ac60 \ + --hash=sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1 \ + --hash=sha256:296f4c8ed03ca7476813fe666c9ea97869a8d7aec972618671b33a38a5182ef4 \ + --hash=sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717 \ + --hash=sha256:2b16ec437a8c8a965ecf95739448dd938b5c7f56e67ea009f4300d8df05f32b7 \ + --hash=sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc \ + --hash=sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe \ + --hash=sha256:357f5bb5c377a82e105e44bd3d52ba22b616f7b9773714bff93573988ef0a5fb \ + --hash=sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75 \ + --hash=sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6 \ + --hash=sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e \ + --hash=sha256:3d233076ccf9e450c8b3bc6720af226b898ef5d051a2d145f7d765e6e9f9bcff \ + --hash=sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566 \ + --hash=sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12 \ + --hash=sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367 \ + --hash=sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874 \ + --hash=sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf \ + --hash=sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566 \ + --hash=sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a \ + --hash=sha256:4b536b39c5199b96fc6245eb5fb796c497381d3942f169e44e8e392b29c9ebcc \ + --hash=sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a \ + --hash=sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1 \ + --hash=sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6 \ + --hash=sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61 \ + --hash=sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726 \ + --hash=sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49 \ + --hash=sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44 \ + --hash=sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af \ + --hash=sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa \ + --hash=sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153 \ + --hash=sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc \ + --hash=sha256:5d4e2366a9c7b837555cf02fb9be2e3167d333aff716332ef1b7c3a142ec40c5 \ + --hash=sha256:5fd37c406dd6dc85aa743e214cef35dc54bbdd1419baac4f6ae5e5b1a2976938 \ + --hash=sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf \ + --hash=sha256:66c1f011f45a3b33d7bcb22daed4b29c0c9e2224758b6be00686731e1b46f925 \ + --hash=sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8 \ + --hash=sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c \ + --hash=sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85 \ + --hash=sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e \ + --hash=sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0 \ + --hash=sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1 \ + --hash=sha256:71b749281b816793678ae7f3d0d84bd36e694953822eaad408d682efc5ca18e0 \ + --hash=sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992 \ + --hash=sha256:7c2d1fa3201efaf55d730400d945b5b3ab6e672e100ba0f9a409d950ab25d7db \ + --hash=sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f \ + --hash=sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d \ + --hash=sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1 \ + --hash=sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e \ + --hash=sha256:8c9b3cbe4584636d72ff556d9036e0c9317fa27b3ac1f0f558e7e84d1c9c5900 \ + --hash=sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89 \ + --hash=sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a \ + --hash=sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b \ + --hash=sha256:948dab269721ae9a87fd16c514a0a2c2a1bdb23a9a61b969b0f9d9ee2968546f \ + --hash=sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f \ + --hash=sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1 \ + --hash=sha256:99d43339c83aaf4d32bda60928231848eee470c6bda8d02599cc4cebe872d183 \ + --hash=sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66 \ + --hash=sha256:9a52009f2adffe195d0b605c25ec929d26b36ef986ba85244891dee3b294df21 \ + --hash=sha256:9d2b6caef873b4f09e26ea7e33d65f42b944837563a47a94719cc3544319a0db \ + --hash=sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded \ + --hash=sha256:a0ee98db9c5f80785b266eb805016e36058ac72c51a064040f2bc43b61101cdb \ + --hash=sha256:a129e76735bc792794d5177069691c3217898b9f5cee2b2661471e52ffe13f19 \ + --hash=sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0 \ + --hash=sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165 \ + --hash=sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778 \ + --hash=sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455 \ + --hash=sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f \ + --hash=sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b \ + --hash=sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237 \ + --hash=sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81 \ + --hash=sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859 \ + --hash=sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c \ + --hash=sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835 \ + --hash=sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393 \ + --hash=sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5 \ + --hash=sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641 \ + --hash=sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144 \ + --hash=sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74 \ + --hash=sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db \ + --hash=sha256:cbc3b6dfc728105b2a57c06791eb07a94229202ea75c59db644d7d496b698cac \ + --hash=sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403 \ + --hash=sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9 \ + --hash=sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f \ + --hash=sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311 \ + --hash=sha256:d82ad62b19645419fe79dd63b3f9253e15b30e955c0170e5cebc350c1844e581 \ + --hash=sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36 \ + --hash=sha256:daede9cd44e0f8bdd9e6cc9a607fc81feb80fae7a5fc6cecaff0e0bb32e42d00 \ + --hash=sha256:db65d2af507bbfbdcedb254a11149f894169d90488dd3e7190f7cdcb2d6cd57a \ + --hash=sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f \ + --hash=sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2 \ + --hash=sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7 \ + --hash=sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239 \ + --hash=sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757 \ + --hash=sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72 \ + --hash=sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9 \ + --hash=sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4 \ + --hash=sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24 \ + --hash=sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207 \ + --hash=sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e \ + --hash=sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1 \ + --hash=sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d \ + --hash=sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37 \ + --hash=sha256:f93243fdc5657247533273ac4f86ae106cc6445a0efacb9a1bfe982fcfefd90c \ + --hash=sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e \ + --hash=sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570 \ + --hash=sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af \ + --hash=sha256:fd138803047fb4c062b1c1dd95462f5209456bfab55c734458f15d11da288f8f \ + --hash=sha256:fd2dbc472da1f772a4dae4fa24be938a6c544671a912e30529984dd80400cd88 \ + --hash=sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48 \ + --hash=sha256:fe49d0a85038f36ba9e3ffafa1103e61170b28e95b16622e11be0a0ea07c6781 + # via + # aiohttp + # yarl +protobuf==6.33.6 \ + --hash=sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326 \ + --hash=sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901 \ + --hash=sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3 \ + --hash=sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a \ + --hash=sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135 \ + --hash=sha256:bd56799fb262994b2c2faa1799693c95cc2e22c62f56fb43af311cae45d26f0e \ + --hash=sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3 \ + --hash=sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2 \ + --hash=sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593 \ + --hash=sha256:f443a394af5ed23672bc6c486be138628fbe5c651ccbc536873d7da23d1868cf + # via + # -r deps/requirements_xpu.txt + # grpcio-tools +psutil==7.2.2 \ + --hash=sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372 \ + --hash=sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9 \ + --hash=sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841 \ + --hash=sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63 \ + --hash=sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979 \ + --hash=sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a \ + --hash=sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b \ + --hash=sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9 \ + --hash=sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee \ + --hash=sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312 \ + --hash=sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b \ + --hash=sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9 \ + --hash=sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e \ + --hash=sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc \ + --hash=sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1 \ + --hash=sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf \ + --hash=sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea \ + --hash=sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988 \ + --hash=sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486 \ + --hash=sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00 \ + --hash=sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8 + # via -r deps/requirements_xpu.txt +py-spy==0.4.1 \ + --hash=sha256:1fb8bf71ab8df95a95cc387deed6552934c50feef2cf6456bc06692a5508fd0c \ + --hash=sha256:4972c21890b6814017e39ac233c22572c4a61fd874524ebc5ccab0f2237aee0a \ + --hash=sha256:532d3525538254d1859b49de1fbe9744df6b8865657c9f0e444bf36ce3f19226 \ + --hash=sha256:6a80ec05eb8a6883863a367c6a4d4f2d57de68466f7956b6367d4edd5c61bb29 \ + --hash=sha256:809094208c6256c8f4ccadd31e9a513fe2429253f48e20066879239ba12cd8cc \ + --hash=sha256:d92e522bd40e9bf7d87c204033ce5bb5c828fca45fa28d970f58d71128069fdc \ + --hash=sha256:e53aa53daa2e47c2eef97dd2455b47bb3a7e7f962796a86cc3e7dbde8e6f4db4 \ + --hash=sha256:ee776b9d512a011d1ad3907ed53ae32ce2f3d9ff3e1782236554e22103b5c084 + # via -r deps/requirements_xpu.txt +pybind11-stubgen==2.5.5 \ + --hash=sha256:10824cd2fc5cbbee032b8fb39e6f6c08de232deb309bc66d786a6c6e8a4601bd \ + --hash=sha256:758d6d6bbeefc62ad7f78d5e5bbf357ccf6af83cd4504f5f549403f452942708 + # via -r deps/requirements_xpu.txt +pycparser==3.0 \ + --hash=sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29 \ + --hash=sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992 + # via cffi +pycryptodome==3.23.0 \ + --hash=sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4 \ + --hash=sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c \ + --hash=sha256:14e15c081e912c4b0d75632acd8382dfce45b258667aa3c67caf7a4d4c13f630 \ + --hash=sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f \ + --hash=sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27 \ + --hash=sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a \ + --hash=sha256:350ebc1eba1da729b35ab7627a833a1a355ee4e852d8ba0447fafe7b14504d56 \ + --hash=sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef \ + --hash=sha256:45c69ad715ca1a94f778215a11e66b7ff989d792a4d63b68dc586a1da1392ff5 \ + --hash=sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477 \ + --hash=sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886 \ + --hash=sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a \ + --hash=sha256:573a0b3017e06f2cffd27d92ef22e46aa3be87a2d317a5abf7cc0e84e321bd75 \ + --hash=sha256:63dad881b99ca653302b2c7191998dd677226222a3f2ea79999aa51ce695f720 \ + --hash=sha256:64093fc334c1eccfd3933c134c4457c34eaca235eeae49d69449dc4728079339 \ + --hash=sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625 \ + --hash=sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490 \ + --hash=sha256:6fe8258e2039eceb74dfec66b3672552b6b7d2c235b2dfecc05d16b8921649a8 \ + --hash=sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b \ + --hash=sha256:7ac1080a8da569bde76c0a104589c4f414b8ba296c0b3738cf39a466a9fb1818 \ + --hash=sha256:865d83c906b0fc6a59b510deceee656b6bc1c4fa0d82176e2b77e97a420a996a \ + --hash=sha256:89d4d56153efc4d81defe8b65fd0821ef8b2d5ddf8ed19df31ba2f00872b8002 \ + --hash=sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae \ + --hash=sha256:93837e379a3e5fd2bb00302a47aee9fdf7940d83595be3915752c74033d17ca7 \ + --hash=sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d \ + --hash=sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265 \ + --hash=sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39 \ + --hash=sha256:a176b79c49af27d7f6c12e4b178b0824626f40a7b9fed08f712291b6d54bf566 \ + --hash=sha256:a7fc76bf273353dc7e5207d172b83f569540fc9a28d63171061c42e361d22353 \ + --hash=sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b \ + --hash=sha256:b34e8e11d97889df57166eda1e1ddd7676da5fcd4d71a0062a760e75060514b4 \ + --hash=sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2 \ + --hash=sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575 \ + --hash=sha256:ce64e84a962b63a47a592690bdc16a7eaf709d2c2697ababf24a0def566899a6 \ + --hash=sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843 \ + --hash=sha256:d8e95564beb8782abfd9e431c974e14563a794a4944c29d6d3b7b5ea042110b4 \ + --hash=sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446 \ + --hash=sha256:ddb95b49df036ddd264a0ad246d1be5b672000f12d6961ea2c267083a5e19379 \ + --hash=sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa \ + --hash=sha256:e3f2d0aaf8080bda0587d58fc9fe4766e012441e2eed4269a77de6aea981c8be \ + --hash=sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7 + # via oss2 +pydantic==2.12.5 \ + --hash=sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49 \ + --hash=sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d + # via + # -r deps/requirements_xpu.txt + # fastapi + # openai +pydantic-core==2.41.5 \ + --hash=sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90 \ + --hash=sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740 \ + --hash=sha256:0384e2e1021894b1ff5a786dbf94771e2986ebe2869533874d7e43bc79c6f504 \ + --hash=sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84 \ + --hash=sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33 \ + --hash=sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c \ + --hash=sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0 \ + --hash=sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e \ + --hash=sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0 \ + --hash=sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a \ + --hash=sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34 \ + --hash=sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2 \ + --hash=sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3 \ + --hash=sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815 \ + --hash=sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14 \ + --hash=sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba \ + --hash=sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375 \ + --hash=sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf \ + --hash=sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963 \ + --hash=sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1 \ + --hash=sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808 \ + --hash=sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553 \ + --hash=sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1 \ + --hash=sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2 \ + --hash=sha256:299e0a22e7ae2b85c1a57f104538b2656e8ab1873511fd718a1c1c6f149b77b5 \ + --hash=sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470 \ + --hash=sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2 \ + --hash=sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b \ + --hash=sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660 \ + --hash=sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c \ + --hash=sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093 \ + --hash=sha256:346285d28e4c8017da95144c7f3acd42740d637ff41946af5ce6e5e420502dd5 \ + --hash=sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594 \ + --hash=sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008 \ + --hash=sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a \ + --hash=sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a \ + --hash=sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd \ + --hash=sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284 \ + --hash=sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586 \ + --hash=sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869 \ + --hash=sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294 \ + --hash=sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f \ + --hash=sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66 \ + --hash=sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51 \ + --hash=sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc \ + --hash=sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97 \ + --hash=sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a \ + --hash=sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d \ + --hash=sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9 \ + --hash=sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c \ + --hash=sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07 \ + --hash=sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36 \ + --hash=sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e \ + --hash=sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05 \ + --hash=sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e \ + --hash=sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941 \ + --hash=sha256:707625ef0983fcfb461acfaf14de2067c5942c6bb0f3b4c99158bed6fedd3cf3 \ + --hash=sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612 \ + --hash=sha256:753e230374206729bf0a807954bcc6c150d3743928a73faffee51ac6557a03c3 \ + --hash=sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b \ + --hash=sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe \ + --hash=sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146 \ + --hash=sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11 \ + --hash=sha256:7b93a4d08587e2b7e7882de461e82b6ed76d9026ce91ca7915e740ecc7855f60 \ + --hash=sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd \ + --hash=sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b \ + --hash=sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c \ + --hash=sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a \ + --hash=sha256:873e0d5b4fb9b89ef7c2d2a963ea7d02879d9da0da8d9d4933dee8ee86a8b460 \ + --hash=sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1 \ + --hash=sha256:8bfeaf8735be79f225f3fefab7f941c712aaca36f1128c9d7e2352ee1aa87bdf \ + --hash=sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf \ + --hash=sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858 \ + --hash=sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2 \ + --hash=sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9 \ + --hash=sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2 \ + --hash=sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3 \ + --hash=sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6 \ + --hash=sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770 \ + --hash=sha256:a75dafbf87d6276ddc5b2bf6fae5254e3d0876b626eb24969a574fff9149ee5d \ + --hash=sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc \ + --hash=sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23 \ + --hash=sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26 \ + --hash=sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa \ + --hash=sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8 \ + --hash=sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d \ + --hash=sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3 \ + --hash=sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d \ + --hash=sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034 \ + --hash=sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9 \ + --hash=sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1 \ + --hash=sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56 \ + --hash=sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b \ + --hash=sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c \ + --hash=sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a \ + --hash=sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e \ + --hash=sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9 \ + --hash=sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5 \ + --hash=sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a \ + --hash=sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556 \ + --hash=sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e \ + --hash=sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49 \ + --hash=sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2 \ + --hash=sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9 \ + --hash=sha256:e4f4a984405e91527a0d62649ee21138f8e3d0ef103be488c1dc11a80d7f184b \ + --hash=sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc \ + --hash=sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb \ + --hash=sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0 \ + --hash=sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8 \ + --hash=sha256:e8465ab91a4bd96d36dde3263f06caa6a8a6019e4113f24dc753d79a8b3a3f82 \ + --hash=sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69 \ + --hash=sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b \ + --hash=sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c \ + --hash=sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75 \ + --hash=sha256:f0cd744688278965817fd0839c4a4116add48d23890d468bc436f78beb28abf5 \ + --hash=sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f \ + --hash=sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad \ + --hash=sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b \ + --hash=sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7 \ + --hash=sha256:f41eb9797986d6ebac5e8edff36d5cef9de40def462311b3eb3eeded1431e425 \ + --hash=sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52 + # via pydantic +pyelftools==0.32 \ + --hash=sha256:013df952a006db5e138b1edf6d8a68ecc50630adbd0d83a2d41e7f846163d738 \ + --hash=sha256:6de90ee7b8263e740c8715a925382d4099b354f29ac48ea40d840cf7aa14ace5 + # via triton-xpu +pyyaml==6.0.3 \ + --hash=sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c \ + --hash=sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a \ + --hash=sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3 \ + --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \ + --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \ + --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \ + --hash=sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65 \ + --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \ + --hash=sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0 \ + --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \ + --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \ + --hash=sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6 \ + --hash=sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7 \ + --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \ + --hash=sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007 \ + --hash=sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310 \ + --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \ + --hash=sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9 \ + --hash=sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295 \ + --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \ + --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \ + --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \ + --hash=sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac \ + --hash=sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9 \ + --hash=sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7 \ + --hash=sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35 \ + --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \ + --hash=sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b \ + --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \ + --hash=sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5 \ + --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \ + --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \ + --hash=sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369 \ + --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \ + --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \ + --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \ + --hash=sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065 \ + --hash=sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c \ + --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \ + --hash=sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764 \ + --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \ + --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \ + --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \ + --hash=sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac \ + --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \ + --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \ + --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \ + --hash=sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3 \ + --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \ + --hash=sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4 \ + --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \ + --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \ + --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \ + --hash=sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702 \ + --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \ + --hash=sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788 \ + --hash=sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da \ + --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \ + --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \ + --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \ + --hash=sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba \ + --hash=sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f \ + --hash=sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917 \ + --hash=sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5 \ + --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \ + --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \ + --hash=sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b \ + --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \ + --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \ + --hash=sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3 \ + --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \ + --hash=sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926 \ + --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0 + # via + # -r deps/requirements_xpu.txt + # huggingface-hub + # timm + # transformers +regex==2026.2.28 \ + --hash=sha256:00945d007fd74a9084d2ab79b695b595c6b7ba3698972fadd43e23230c6979c1 \ + --hash=sha256:00f2b8d9615aa165fdff0a13f1a92049bfad555ee91e20d246a51aa0b556c60a \ + --hash=sha256:01d65fd24206c8e1e97e2e31b286c59009636c022eb5d003f52760b0f42155d4 \ + --hash=sha256:02473c954af35dd2defeb07e44182f5705b30ea3f351a7cbffa9177beb14da5d \ + --hash=sha256:03a83cc26aa2acda6b8b9dfe748cf9e84cbd390c424a1de34fdcef58961a297a \ + --hash=sha256:09500be324f49b470d907b3ef8af9afe857f5cca486f853853f7945ddbf75911 \ + --hash=sha256:0b1d2b07614d95fa2bf8a63fd1e98bd8fa2b4848dc91b1efbc8ba219fdd73952 \ + --hash=sha256:0d25a10811de831c2baa6aef3c0be91622f44dd8d31dd12e69f6398efb15e48b \ + --hash=sha256:0d5bef2031cbf38757a0b0bc4298bb4824b6332d28edc16b39247228fbdbad97 \ + --hash=sha256:10d28e19bd4888e4abf43bd3925f3c134c52fdf7259219003588a42e24c2aa25 \ + --hash=sha256:180e08a435a0319e6a4821c3468da18dc7001987e1c17ae1335488dfe7518dd8 \ + --hash=sha256:195237dc327858a7721bf8b0bbbef797554bc13563c3591e91cd0767bacbe359 \ + --hash=sha256:19a9c9e0a8f24f39d575a6a854d516b48ffe4cbdcb9de55cb0570a032556ecff \ + --hash=sha256:1c2c95e1a2b0f89d01e821ff4de1be4b5d73d1f4b0bf679fa27c1ad8d2327f1a \ + --hash=sha256:1d367257cd86c1cbb97ea94e77b373a0bbc2224976e247f173d19e8f18b4afa7 \ + --hash=sha256:1e496956106fd59ba6322a8ea17141a27c5040e5ee8f9433ae92d4e5204462a0 \ + --hash=sha256:1f8b17be5c27a684ea6759983c13506bd77bfc7c0347dff41b18ce5ddd2ee09a \ + --hash=sha256:2234059cfe33d9813a3677ef7667999caea9eeaa83fef98eb6ce15c6cf9e0215 \ + --hash=sha256:25b6eb660c5cf4b8c3407a1ed462abba26a926cc9965e164268a3267bcc06a43 \ + --hash=sha256:2954379dd20752e82d22accf3ff465311cbb2bac6c1f92c4afd400e1757f7451 \ + --hash=sha256:2afa673660928d0b63d84353c6c08a8a476ddfc4a47e11742949d182e6863ce8 \ + --hash=sha256:2b2b23587b26496ff5fd40df4278becdf386813ec00dc3533fa43a4cf0e2ad3c \ + --hash=sha256:2fb950ac1d88e6b6a9414381f403797b236f9fa17e1eee07683af72b1634207b \ + --hash=sha256:3935174fa4d9f70525a4367aaff3cb8bc0548129d114260c29d9dfa4a5b41692 \ + --hash=sha256:39bb5727650b9a0275c6a6690f9bb3fe693a7e6cc5c3155b1240aedf8926423e \ + --hash=sha256:3b24bd7e9d85dc7c6a8bd2aa14ecd234274a0248335a02adeb25448aecdd420d \ + --hash=sha256:4390c365fd2d45278f45afd4673cb90f7285f5701607e3ad4274df08e36140ae \ + --hash=sha256:481df4623fa4969c8b11f3433ed7d5e3dc9cec0f008356c3212b3933fb77e3d8 \ + --hash=sha256:4f5c0b182ad4269e7381b7c27fdb0408399881f7a92a4624fd5487f2971dfc11 \ + --hash=sha256:50c2fc924749543e0eacc93ada6aeeb3ea5f6715825624baa0dccaec771668ae \ + --hash=sha256:511f7419f7afab475fd4d639d4aedfc54205bcb0800066753ef68a59f0f330b5 \ + --hash=sha256:516604edd17b1c2c3e579cf4e9b25a53bf8fa6e7cedddf1127804d3e0140ca64 \ + --hash=sha256:52b017b35ac2214d0db5f4f90e303634dc44e4aba4bd6235a27f97ecbe5b0472 \ + --hash=sha256:5a932ea8ad5d0430351ff9c76c8db34db0d9f53c1d78f06022a21f4e290c5c18 \ + --hash=sha256:5cdcc17d935c8f9d3f4db5c2ebe2640c332e3822ad5d23c2f8e0228e6947943a \ + --hash=sha256:5d10303dd18cedfd4d095543998404df656088240bcfd3cd20a8f95b861f74bd \ + --hash=sha256:5e68192bb3a1d6fb2836da24aa494e413ea65853a21505e142e5b1064a595f3d \ + --hash=sha256:64e7c6ad614573e0640f271e811a408d79a9e1fe62a46adb602f598df42a818d \ + --hash=sha256:6591f281cb44dc13de9585b552cec6fc6cf47fb2fe7a48892295ee9bc4a612f9 \ + --hash=sha256:69fc560ccbf08a09dc9b52ab69cacfae51e0ed80dc5693078bdc97db2f91ae96 \ + --hash=sha256:6d63a07e5ec8ce7184452cb00c41c37b49e67dc4f73b2955b5b8e782ea970784 \ + --hash=sha256:6db7bfae0f8a2793ff1f7021468ea55e2699d0790eb58ee6ab36ae43aa00bc5b \ + --hash=sha256:71a911098be38c859ceb3f9a9ce43f4ed9f4c6720ad8684a066ea246b76ad9ff \ + --hash=sha256:73cdcdbba8028167ea81490c7f45280113e41db2c7afb65a276f4711fa3bcbff \ + --hash=sha256:78454178c7df31372ea737996fb7f36b3c2c92cccc641d251e072478afb4babc \ + --hash=sha256:7900157786428a79615a8264dac1f12c9b02957c473c8110c6b1f972dcecaddf \ + --hash=sha256:7ab218076eb0944549e7fe74cf0e2b83a82edb27e81cc87411f76240865e04d5 \ + --hash=sha256:7c1b34dfa72f826f535b20712afa9bb3ba580020e834f3c69866c5bddbf10098 \ + --hash=sha256:851fa70df44325e1e4cdb79c5e676e91a78147b1b543db2aec8734d2add30ec2 \ + --hash=sha256:864cdd1a2ef5716b0ab468af40139e62ede1b3a53386b375ec0786bb6783fc05 \ + --hash=sha256:8710d61737b0c0ce6836b1da7109f20d495e49b3809f30e27e9560be67a257bf \ + --hash=sha256:9036b400b20e4858d56d117108d7813ed07bb7803e3eed766675862131135ca6 \ + --hash=sha256:9185cc63359862a6e80fe97f696e04b0ad9a11c4ac0a4a927f979f611bfe3768 \ + --hash=sha256:948c12ef30ecedb128903c2c2678b339746eb7c689c5c21957c4a23950c96d15 \ + --hash=sha256:94d63db12e45a9b9f064bfe4800cefefc7e5f182052e4c1b774d46a40ab1d9bb \ + --hash=sha256:96f6269a2882fbb0ee76967116b83679dc628e68eaea44e90884b8d53d833881 \ + --hash=sha256:97054c55db06ab020342cc0d35d6f62a465fa7662871190175f1ad6c655c028f \ + --hash=sha256:98adf340100cbe6fbaf8e6dc75e28f2c191b1be50ffefe292fb0e6f6eefdb0d8 \ + --hash=sha256:99985a2c277dcb9ccb63f937451af5d65177af1efdeb8173ac55b61095a0a05c \ + --hash=sha256:9b65d33a17101569f86d9c5966a8b1d7fbf8afdda5a8aa219301b0a80f58cf7d \ + --hash=sha256:9dd450db6458387167e033cfa80887a34c99c81d26da1bf8b0b41bf8c9cac88e \ + --hash=sha256:a25c7701e4f7a70021db9aaf4a4a0a67033c6318752146e03d1b94d32006217e \ + --hash=sha256:a448af01e3d8031c89c5d902040b124a5e921a25c4e5e07a861ca591ce429341 \ + --hash=sha256:a5dac14d0872eeb35260a8e30bac07ddf22adc1e3a0635b52b02e180d17c9c7e \ + --hash=sha256:a729e47d418ea11d03469f321aaf67cdee8954cde3ff2cf8403ab87951ad10f2 \ + --hash=sha256:aaffaecffcd2479ce87aa1e74076c221700b7c804e48e98e62500ee748f0f550 \ + --hash=sha256:b059e71ec363968671693a78c5053bd9cb2fe410f9b8e4657e88377ebd603a2e \ + --hash=sha256:b387a0d092dac157fb026d737dde35ff3e49ef27f285343e7c6401851239df27 \ + --hash=sha256:b389c61aa28a79c2e0527ac36da579869c2e235a5b208a12c5b5318cda2501d8 \ + --hash=sha256:b42f7466e32bf15a961cf09f35fa6323cc72e64d3d2c990b10de1274a5da0a59 \ + --hash=sha256:b49eb78048c6354f49e91e4b77da21257fecb92256b6d599ae44403cab30b05b \ + --hash=sha256:b5acd4b6a95f37c3c3828e5d053a7d4edaedb85de551db0153754924cb7c83e3 \ + --hash=sha256:b8b3f1be1738feadc69f62daa250c933e85c6f34fa378f54a7ff43807c1b9117 \ + --hash=sha256:b8cf76f1a29f0e99dcfd7aef1551a9827588aae5a737fe31442021165f1920dc \ + --hash=sha256:ba55c50f408fb5c346a3a02d2ce0ebc839784e24f7c9684fde328ff063c3cdea \ + --hash=sha256:bba2b18d70eeb7b79950f12f633beeecd923f7c9ad6f6bae28e59b4cb3ab046b \ + --hash=sha256:bbb882061f742eb5d46f2f1bd5304055be0a66b783576de3d7eef1bed4778a6e \ + --hash=sha256:bcb399ed84eabf4282587ba151f2732ad8168e66f1d3f85b1d038868fe547703 \ + --hash=sha256:bd477d5f79920338107f04aa645f094032d9e3030cc55be581df3d1ef61aa318 \ + --hash=sha256:bec23c11cbbf09a4df32fe50d57cbdd777bc442269b6e39a1775654f1c95dee2 \ + --hash=sha256:c0b5ccbb8ffb433939d248707d4a8b31993cb76ab1a0187ca886bf50e96df952 \ + --hash=sha256:c15af43c72a7fb0c97cbc66fa36a43546eddc5c06a662b64a0cbf30d6ac40944 \ + --hash=sha256:c7815afb0ca45456613fdaf60ea9c993715511c8d53a83bc468305cbc0ee23c7 \ + --hash=sha256:cb3b1db8ff6c7b8bf838ab05583ea15230cb2f678e569ab0e3a24d1e8320940b \ + --hash=sha256:d0b02e8b7e5874b48ae0f077ecca61c1a6a9f9895e9c6dfb191b55b242862033 \ + --hash=sha256:d6b08a06976ff4fb0d83077022fde3eca06c55432bb997d8c0495b9a4e9872f4 \ + --hash=sha256:d6cfe798d8da41bb1862ed6e0cba14003d387c3c0c4a5d45591076ae9f0ce2f8 \ + --hash=sha256:d8511a01d0e4ee1992eb3ba19e09bc1866fe03f05129c3aec3fdc4cbc77aad3f \ + --hash=sha256:dc8ed8c3f41c27acb83f7b6a9eb727a73fc6663441890c5cb3426a5f6a91ce7d \ + --hash=sha256:dd8847c4978bc3c7e6c826fb745f5570e518b8459ac2892151ce6627c7bc00d5 \ + --hash=sha256:de0cf053139f96219ccfabb4a8dd2d217c8c82cb206c91d9f109f3f552d6b43d \ + --hash=sha256:dee50f1be42222f89767b64b283283ef963189da0dda4a515aa54a5563c62dec \ + --hash=sha256:e1e7b24cb3ae9953a560c563045d1ba56ee4749fbd05cf21ba571069bd7be81b \ + --hash=sha256:e59bc8f30414d283ae8ee1617b13d8112e7135cb92830f0ec3688cb29152585a \ + --hash=sha256:e61eea47230eba62a31f3e8a0e3164d0f37ef9f40529fb2c79361bc6b53d2a92 \ + --hash=sha256:e621fb7c8dc147419b28e1702f58a0177ff8308a76fa295c71f3e7827849f5d9 \ + --hash=sha256:e71dcecaa113eebcc96622c17692672c2d104b1d71ddf7adeda90da7ddeb26fc \ + --hash=sha256:e7ce83654d1ab701cb619285a18a8e5a889c1216d746ddc710c914ca5fd71022 \ + --hash=sha256:e8c8cb2deba42f5ec1ede46374e990f8adc5e6456a57ac1a261b19be6f28e4e6 \ + --hash=sha256:ec0c608b7a7465ffadb344ed7c987ff2f11ee03f6a130b569aa74d8a70e8333c \ + --hash=sha256:ec6f5674c5dc836994f50f1186dd1fafde4be0666aae201ae2fcc3d29d8adf27 \ + --hash=sha256:edb1b1b3a5576c56f08ac46f108c40333f222ebfd5cf63afdfa3aab0791ebe5b \ + --hash=sha256:ef77bdde9c9eba3f7fa5b58084b29bbcc74bcf55fdbeaa67c102a35b5bd7e7cc \ + --hash=sha256:f2791948f7c70bb9335a9102df45e93d428f4b8128020d85920223925d73b9e1 \ + --hash=sha256:f467cb602f03fbd1ab1908f68b53c649ce393fde056628dc8c7e634dab6bfc07 \ + --hash=sha256:f8ed9a5d4612df9d4de15878f0bc6aa7a268afbe5af21a3fdd97fa19516e978c \ + --hash=sha256:fa539be029844c0ce1114762d2952ab6cfdd7c7c9bd72e0db26b94c3c36dcc5a \ + --hash=sha256:fb1c4ff62277d87a7335f2c1ea4e0387b8f2b3ad88a64efd9943906aafad4f33 \ + --hash=sha256:fb4db2f17e6484904f986c5a657cec85574c76b5c5e61c7aae9ffa1bc6224f95 \ + --hash=sha256:fb66e5245db9652abd7196ace599b04d9c0e4aa7c8f0e2803938377835780081 \ + --hash=sha256:fc48c500838be6882b32748f60a15229d2dea96e59ef341eaa96ec83538f498d \ + --hash=sha256:fcf26c3c6d0da98fada8ae4ef0aa1c3405a431c0a77eb17306d38a89b02adcd7 \ + --hash=sha256:fd0ce43e71d825b7c0661f9c54d4d74bd97c56c3fd102a8985bcfea48236bacb \ + --hash=sha256:fd63453f10d29097cc3dc62d070746523973fb5aa1c66d25f8558bebd47fed61 + # via + # tiktoken + # transformers +requests==2.32.5 \ + --hash=sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6 \ + --hash=sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf + # via + # -r deps/requirements_xpu.txt + # dashscope + # huggingface-hub + # oss2 + # pooch + # tiktoken + # transformers +safetensors==0.7.0 \ + --hash=sha256:0071bffba4150c2f46cae1432d31995d77acfd9f8db598b5d1a2ce67e8440ad2 \ + --hash=sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0 \ + --hash=sha256:12f49080303fa6bb424b362149a12949dfbbf1e06811a88f2307276b0c131afd \ + --hash=sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981 \ + --hash=sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a \ + --hash=sha256:473b32699f4200e69801bf5abf93f1a4ecd432a70984df164fc22ccf39c4a6f3 \ + --hash=sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d \ + --hash=sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0 \ + --hash=sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85 \ + --hash=sha256:6999421eb8ba9df4450a16d9184fcb7bef26240b9f98e95401f17af6c2210b71 \ + --hash=sha256:7b95a3fa7b3abb9b5b0e07668e808364d0d40f6bbbf9ae0faa8b5b210c97b140 \ + --hash=sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104 \ + --hash=sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57 \ + --hash=sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4 \ + --hash=sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba \ + --hash=sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517 \ + --hash=sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b \ + --hash=sha256:cfdead2f57330d76aa7234051dadfa7d4eedc0e5a27fd08e6f96714a92b00f09 \ + --hash=sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755 \ + --hash=sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48 \ + --hash=sha256:dc92bc2db7b45bda4510e4f51c59b00fe80b2d6be88928346e4294ce1c2abe7c \ + --hash=sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542 \ + --hash=sha256:f4729811a6640d019a4b7ba8638ee2fd21fa5ca8c7e7bdf0fed62068fcaac737 + # via + # -r deps/requirements_xpu.txt + # timm + # transformers +scikit-learn==1.8.0 \ + --hash=sha256:00d6f1d66fbcf4eba6e356e1420d33cc06c70a45bb1363cd6f6a8e4ebbbdece2 \ + --hash=sha256:0d6ae97234d5d7079dc0040990a6f7aeb97cb7fa7e8945f1999a429b23569e0a \ + --hash=sha256:146b4d36f800c013d267b29168813f7a03a43ecd2895d04861f1240b564421da \ + --hash=sha256:15fc3b5d19cc2be65404786857f2e13c70c83dd4782676dd6814e3b89dc8f5b9 \ + --hash=sha256:2838551e011a64e3053ad7618dda9310175f7515f1742fa2d756f7c874c05961 \ + --hash=sha256:29ffc74089f3d5e87dfca4c2c8450f88bdc61b0fc6ed5d267f3988f19a1309f6 \ + --hash=sha256:2de443b9373b3b615aec1bb57f9baa6bb3a9bd093f1269ba95c17d870422b271 \ + --hash=sha256:35c007dedb2ffe38fe3ee7d201ebac4a2deccd2408e8621d53067733e3c74809 \ + --hash=sha256:3bad7565bc9cf37ce19a7c0d107742b320c1285df7aab1a6e2d28780df167242 \ + --hash=sha256:4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4 \ + --hash=sha256:4511be56637e46c25721e83d1a9cea9614e7badc7040c4d573d75fbe257d6fd7 \ + --hash=sha256:5025ce924beccb28298246e589c691fe1b8c1c96507e6d27d12c5fadd85bfd76 \ + --hash=sha256:56079a99c20d230e873ea40753102102734c5953366972a71d5cb39a32bc40c6 \ + --hash=sha256:5e30adb87f0cc81c7690a84f7932dd66be5bac57cfe16b91cb9151683a4a2d3b \ + --hash=sha256:5fb63362b5a7ddab88e52b6dbb47dac3fd7dafeee740dc6c8d8a446ddedade8e \ + --hash=sha256:6b595b07a03069a2b1740dc08c2299993850ea81cce4fe19b2421e0c970de6b7 \ + --hash=sha256:72358cce49465d140cc4e7792015bb1f0296a9742d5622c67e31399b75468b9e \ + --hash=sha256:74b66d8689d52ed04c271e1329f0c61635bcaf5b926db9b12d58914cdc01fe57 \ + --hash=sha256:7cc267b6108f0a1499a734167282c00c4ebf61328566b55ef262d48e9849c735 \ + --hash=sha256:80832434a6cc114f5219211eec13dcbc16c2bac0e31ef64c6d346cde3cf054cb \ + --hash=sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb \ + --hash=sha256:8fdf95767f989b0cfedb85f7ed8ca215d4be728031f56ff5a519ee1e3276dc2e \ + --hash=sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd \ + --hash=sha256:a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a \ + --hash=sha256:a69525355a641bf8ef136a7fa447672fb54fe8d60cab5538d9eb7c6438543fb9 \ + --hash=sha256:ada8121bcb4dac28d930febc791a69f7cb1673c8495e5eee274190b73a4559c1 \ + --hash=sha256:bf97c10a3f5a7543f9b88cbf488d33d175e9146115a451ae34568597ba33dcde \ + --hash=sha256:c22a2da7a198c28dd1a6e1136f19c830beab7fdca5b3e5c8bba8394f8a5c45b3 \ + --hash=sha256:c2656924ec73e5939c76ac4c8b026fc203b83d8900362eb2599d8aee80e4880f \ + --hash=sha256:c57b1b610bd1f40ba43970e11ce62821c2e6569e4d74023db19c6b26f246cb3b \ + --hash=sha256:eddde82a035681427cbedded4e6eff5e57fa59216c2e3e90b10b19ab1d0a65c3 \ + --hash=sha256:edec98c5e7c128328124a029bceb09eda2d526997780fef8d65e9a69eead963e \ + --hash=sha256:ee787491dbfe082d9c3013f01f5991658b0f38aa8177e4cd4bf434c58f551702 \ + --hash=sha256:f28dd15c6bb0b66ba09728cf09fd8736c304be29409bd8445a080c1280619e8c \ + --hash=sha256:f984ca4b14914e6b4094c5d52a32ea16b49832c03bd17a110f004db3c223e8e1 \ + --hash=sha256:fb65db5d7531bccf3a4f6bec3462223bea71384e2cda41da0f10b7c292b9e7c4 \ + --hash=sha256:fe1c011a640a9f0791146011dfd3c7d9669785f9fed2b2a5f9e207536cf5c2fd + # via + # librosa + # sentence-transformers +scipy==1.17.1 \ + --hash=sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0 \ + --hash=sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458 \ + --hash=sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118 \ + --hash=sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39 \ + --hash=sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e \ + --hash=sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6 \ + --hash=sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec \ + --hash=sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21 \ + --hash=sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1 \ + --hash=sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6 \ + --hash=sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce \ + --hash=sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8 \ + --hash=sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448 \ + --hash=sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19 \ + --hash=sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b \ + --hash=sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87 \ + --hash=sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4 \ + --hash=sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9 \ + --hash=sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b \ + --hash=sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082 \ + --hash=sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464 \ + --hash=sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87 \ + --hash=sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c \ + --hash=sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369 \ + --hash=sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad \ + --hash=sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f \ + --hash=sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c \ + --hash=sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475 \ + --hash=sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd \ + --hash=sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866 \ + --hash=sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d \ + --hash=sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6 \ + --hash=sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb \ + --hash=sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca \ + --hash=sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0 \ + --hash=sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca \ + --hash=sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d \ + --hash=sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee \ + --hash=sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4 \ + --hash=sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717 \ + --hash=sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49 \ + --hash=sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2 \ + --hash=sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a \ + --hash=sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350 \ + --hash=sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950 \ + --hash=sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b \ + --hash=sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086 \ + --hash=sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444 \ + --hash=sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068 \ + --hash=sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff \ + --hash=sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a \ + --hash=sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50 \ + --hash=sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696 \ + --hash=sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21 \ + --hash=sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c \ + --hash=sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484 \ + --hash=sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118 \ + --hash=sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3 \ + --hash=sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea \ + --hash=sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293 \ + --hash=sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76 + # via + # librosa + # scikit-learn + # sentence-transformers +sentence-transformers==2.7.0 \ + --hash=sha256:2f7df99d1c021dded471ed2d079e9d1e4fc8e30ecb06f957be060511b36f24ea \ + --hash=sha256:6a7276b05a95931581bbfa4ba49d780b2cf6904fa4a171ec7fd66c343f761c98 + # via -r deps/requirements_xpu.txt +sentencepiece==0.2.1 \ + --hash=sha256:010f025a544ef770bb395091d57cb94deb9652d8972e0d09f71d85d5a0816c8c \ + --hash=sha256:017f97b274d4b0baa84b2dc743bf4517be81156f413bb24f12aacacde378e5ab \ + --hash=sha256:01e6912125cb45d3792f530a4d38f8e21bf884d6b4d4ade1b2de5cf7a8d2a52b \ + --hash=sha256:02593eca45440ef39247cee8c47322a34bdcc1d8ae83ad28ba5a899a2cf8d79a \ + --hash=sha256:097f3394e99456e9e4efba1737c3749d7e23563dd1588ce71a3d007f25475fff \ + --hash=sha256:0a0d15781a171d188b661ae4bde1d998c303f6bd8621498c50c671bd45a4798e \ + --hash=sha256:0a81799d0a68d618e89063fb423c3001a034c893069135ffe51fee439ae474d6 \ + --hash=sha256:0c0f672da370cc490e4c59d89e12289778310a0e71d176c541e4834759e1ae07 \ + --hash=sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b \ + --hash=sha256:105e36e75cbac1292642045458e8da677b2342dcd33df503e640f0b457cb6751 \ + --hash=sha256:10ed3dab2044c47f7a2e7b4969b0c430420cdd45735d78c8f853191fa0e3148b \ + --hash=sha256:1855f57db07b51fb51ed6c9c452f570624d2b169b36f0f79ef71a6e6c618cd8b \ + --hash=sha256:2005242a16d2dc3ac5fe18aa7667549134d37854823df4c4db244752453b78a8 \ + --hash=sha256:22c4ebcb3c6ab1496ab1c37c79ef7bb563b8726f29548c30773b7a4cb152df1a \ + --hash=sha256:251874d720ac7f28024a168501f3c7bb15d1802245f6e66de565f18bbb9b5eaa \ + --hash=sha256:27e38eee653abc3d387862e67bc5c8b6f428cd604e688b85d29170b7e725c26c \ + --hash=sha256:2af5a1fb05013332ad94343b8b5f3973e006a2dde2dfba55a819549e054e2f0f \ + --hash=sha256:2f27ae6deea72efdb6f361750c92f6c21fd0ad087445082770cc34015213c526 \ + --hash=sha256:33f068c9382dc2e7c228eedfd8163b52baa86bb92f50d0488bf2b7da7032e484 \ + --hash=sha256:39f8651bd10974eafb9834ce30d9bcf5b73e1fc798a7f7d2528f9820ca86e119 \ + --hash=sha256:3d165fbb9bf8fba35f1946ba2617c3f9995679f07438325f07c026d53f33e746 \ + --hash=sha256:477c81505db072b3ab627e7eab972ea1025331bd3a92bacbf798df2b75ea86ec \ + --hash=sha256:4cdc7c36234fda305e85c32949c5211faaf8dd886096c7cea289ddc12a2d02de \ + --hash=sha256:4f5a3e0d9f445ed9d66c0fec47d4b23d12cfc858b407a03c194c1b26c2ac2a63 \ + --hash=sha256:56dd39a3c4d6493db3cdca7e8cc68c6b633f0d4195495cbadfcf5af8a22d05a6 \ + --hash=sha256:57cae326c8727de58c85977b175af132a7138d84c764635d7e71bbee7e774133 \ + --hash=sha256:5d0350b686c320068702116276cfb26c066dc7e65cfef173980b11bb4d606719 \ + --hash=sha256:5e4366c97b68218fd30ea72d70c525e6e78a6c0a88650f57ac4c43c63b234a9d \ + --hash=sha256:60937c959e6f44159fdd9f56fbdd302501f96114a5ba436829496d5f32d8de3f \ + --hash=sha256:6356d0986b8b8dc351b943150fcd81a1c6e6e4d439772e8584c64230e58ca987 \ + --hash=sha256:6d297a1748d429ba8534eebe5535448d78b8acc32d00a29b49acf28102eeb094 \ + --hash=sha256:733e59ff1794d26db706cd41fc2d7ca5f6c64a820709cb801dc0ea31780d64ab \ + --hash=sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad \ + --hash=sha256:814978ac05130dd5812b4b03215c766bc6abaef13e7bd72bc534e4d1e12e9a4c \ + --hash=sha256:82d9ead6591015f009cb1be1cb1c015d5e6f04046dbb8c9588b931e869a29728 \ + --hash=sha256:881b2e44b14fc19feade3cbed314be37de639fc415375cefaa5bc81a4be137fd \ + --hash=sha256:891ade6503dd93d418c03993f7d6a8aa20260c422cefff5096b9068185e67642 \ + --hash=sha256:89a3ea015517c42c0341d0d962f3e6aaf2cf10d71b1932d475c44ba48d00aa2b \ + --hash=sha256:8dd4b477a7b069648d19363aad0cab9bad2f4e83b2d179be668efa672500dc94 \ + --hash=sha256:8f8ba89a3acb3dc1ae90f65ec1894b0b9596fdb98ab003ff38e058f898b39bc7 \ + --hash=sha256:9076430ac25dfa7147d9d05751dbc66a04bc1aaac371c07f84952979ea59f0d0 \ + --hash=sha256:92b3816aa2339355fda2c8c4e021a5de92180b00aaccaf5e2808972e77a4b22f \ + --hash=sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167 \ + --hash=sha256:a19adcec27c524cb7069a1c741060add95f942d1cbf7ad0d104dffa0a7d28a2b \ + --hash=sha256:a483fd29a34c3e34c39ac5556b0a90942bec253d260235729e50976f5dba1068 \ + --hash=sha256:ac650534e2251083c5f75dde4ff28896ce7c8904133dc8fef42780f4d5588fcd \ + --hash=sha256:ad8493bea8432dae8d6830365352350f3b4144415a1d09c4c8cb8d30cf3b6c3c \ + --hash=sha256:afefe50a0cdcb4f2fd9733cb52001a2c164181ee2d82c32d38f5b1b326a8528c \ + --hash=sha256:b3616ad246f360e52c85781e47682d31abfb6554c779e42b65333d4b5f44ecc0 \ + --hash=sha256:b81a24733726e3678d2db63619acc5a8dccd074f7aa7a54ecd5ca33ca6d2d596 \ + --hash=sha256:c415c9de1447e0a74ae3fdb2e52f967cb544113a3a5ce3a194df185cbc1f962f \ + --hash=sha256:c6c8f42949f419ff8c7e9960dbadcfbc982d7b5efc2f6748210d3dd53a7de062 \ + --hash=sha256:c7f0fd2f2693309e6628aeeb2e2faf6edd221134dfccac3308ca0de01f8dab47 \ + --hash=sha256:c7f54a31cde6fa5cb030370566f68152a742f433f8d2be458463d06c208aef33 \ + --hash=sha256:c83b85ab2d6576607f31df77ff86f28182be4a8de6d175d2c33ca609925f5da1 \ + --hash=sha256:caa4e560c72c151da80036aecc2159e51a7fd8ae9efebefd96860460ce6bd025 \ + --hash=sha256:d3233770f78e637dc8b1fda2cd7c3b99ec77e7505041934188a4e7fe751de3b0 \ + --hash=sha256:d7b670879c370d350557edabadbad1f6561a9e6968126e6debca4029e5547820 \ + --hash=sha256:d8b1d91545578852f128650b8cce4ec20f93d39b378ff554ebe66290f2dabb92 \ + --hash=sha256:d9381351182ff9888cc80e41c632e7e274b106f450de33d67a9e8f6043da6f76 \ + --hash=sha256:daeb5e9e9fcad012324807856113708614d534f596d5008638eb9b40112cd9e4 \ + --hash=sha256:dcd8161eee7b41aae57ded06272905dbd680a0a04b91edd0f64790c796b2f706 \ + --hash=sha256:e10fa50bdbaa5e2445dbd387979980d391760faf0ec99a09bd7780ff37eaec44 \ + --hash=sha256:e37e4b4c4a11662b5db521def4e44d4d30ae69a1743241412a93ae40fdcab4bb \ + --hash=sha256:e52144670738b4b477fade6c2a9b6af71a8d0094514c9853ac9f6fc1fcfabae7 + # via -r deps/requirements_xpu.txt +setproctitle==1.3.7 \ + --hash=sha256:00afa6fc507967d8c9d592a887cdc6c1f5742ceac6a4354d111ca0214847732c \ + --hash=sha256:01f27b5b72505b304152cb0bd7ff410cc4f2d69ac70c21a7fdfa64400a68642d \ + --hash=sha256:02432f26f5d1329ab22279ff863c83589894977063f59e6c4b4845804a08f8c2 \ + --hash=sha256:047138279f9463f06b858e579cc79580fbf7a04554d24e6bddf8fe5dddbe3d4c \ + --hash=sha256:0564a936ea687cd24dffcea35903e2a20962aa6ac20e61dd3a207652401492dd \ + --hash=sha256:0b5074649797fd07c72ca1f6bff0406f4a42e1194faac03ecaab765ce605866f \ + --hash=sha256:10e92915c4b3086b1586933a36faf4f92f903c5554f3c34102d18c7d3f5378e9 \ + --hash=sha256:134e7f66703a1d92c0a9a0a417c580f2cc04b93d31d3fc0dd43c3aa194b706e1 \ + --hash=sha256:13fe37951dda1a45c35d77d06e3da5d90e4f875c4918a7312b3b4556cfa7ff64 \ + --hash=sha256:1403d2abfd32790b6369916e2313dffbe87d6b11dca5bbd898981bcde48e7a2b \ + --hash=sha256:14c7eba8d90c93b0e79c01f0bd92a37b61983c27d6d7d5a3b5defd599113d60e \ + --hash=sha256:1607b963e7b53e24ec8a2cb4e0ab3ae591d7c6bf0a160feef0551da63452b37f \ + --hash=sha256:1fae595d032b30dab4d659bece20debd202229fce12b55abab978b7f30783d73 \ + --hash=sha256:23e520776c445478a67ee71b2a3c1ffdafbe1f9f677239e03d7e2cc635954e18 \ + --hash=sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629 \ + --hash=sha256:2a4e03bd9aa5d10b8702f00ec1b740691da96b5003432f3000d60c56f1c2b4d3 \ + --hash=sha256:2dc99aec591ab6126e636b11035a70991bc1ab7a261da428491a40b84376654e \ + --hash=sha256:316664d8b24a5c91ee244460bdaf7a74a707adaa9e14fbe0dc0a53168bb9aba1 \ + --hash=sha256:318ddcf88dafddf33039ad41bc933e1c49b4cb196fe1731a209b753909591680 \ + --hash=sha256:3384e682b158d569e85a51cfbde2afd1ab57ecf93ea6651fe198d0ba451196ee \ + --hash=sha256:35a2cabcfdea4643d7811cfe9f3d92366d282b38ef5e7e93e25dafb6f97b0a59 \ + --hash=sha256:376761125ab5dab822d40eaa7d9b7e876627ecd41de8fa5336713b611b47ccef \ + --hash=sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a \ + --hash=sha256:45e3ef48350abb49cf937d0a8ba15e42cee1e5ae13ca41a77c66d1abc27a5070 \ + --hash=sha256:46178672599b940368d769474fe13ecef1b587d58bb438ea72b9987f74c56ea5 \ + --hash=sha256:47d36e418ab86b3bc7946e27155e281a743274d02cd7e545f5d628a2875d32f9 \ + --hash=sha256:4a5e212bf438a4dbeece763f4962ad472c6008ff6702e230b4f16a037e2f6f29 \ + --hash=sha256:502b902a0e4c69031b87870ff4986c290ebbb12d6038a70639f09c331b18efb2 \ + --hash=sha256:52b054a61c99d1b72fba58b7f5486e04b20fefc6961cd76722b424c187f362ed \ + --hash=sha256:5818e4080ac04da1851b3ec71e8a0f64e3748bf9849045180566d8b736702416 \ + --hash=sha256:585edf25e54e21a94ccb0fe81ad32b9196b69ebc4fc25f81da81fb8a50cca9e4 \ + --hash=sha256:5ce2613e1361959bff81317dc30a60adb29d8132b6159608a783878fc4bc4bbc \ + --hash=sha256:5fa1953126a3b9bd47049d58c51b9dac72e78ed120459bd3aceb1bacee72357c \ + --hash=sha256:6134c63853d87a4897ba7d5cc0e16abfa687f6c66fc09f262bb70d67718f2309 \ + --hash=sha256:61e96febced3f61b766115381d97a21a6265a0f29188a791f6df7ed777aef698 \ + --hash=sha256:690b4776f9c15aaf1023bb07d7c5b797681a17af98a4a69e76a1d504e41108b7 \ + --hash=sha256:6915964a6dda07920a1159321dcd6d94fc7fc526f815ca08a8063aeca3c204f1 \ + --hash=sha256:6da835e76ae18574859224a75db6e15c4c2aaa66d300a57efeaa4c97ca4c7381 \ + --hash=sha256:6f1be447456fe1e16c92f5fb479404a850d8f4f4ff47192fde14a59b0bae6a0a \ + --hash=sha256:6fc87caf9e323ac426910306c3e5d3205cd9f8dcac06d233fcafe9337f0928a3 \ + --hash=sha256:7081f193dab22df2c36f9fc6d113f3793f83c27891af8fe30c64d89d9a37e152 \ + --hash=sha256:7f47accafac7fe6535ba8ba9efd59df9d84a6214565108d0ebb1199119c9cbbd \ + --hash=sha256:7f9e9e3ff135cbcc3edd2f4cf29b139f4aca040d931573102742db70ff428c17 \ + --hash=sha256:80b6a562cbc92b289c28f34ce709a16b26b1696e9b9a0542a675ce3a788bdf3f \ + --hash=sha256:80c36c6a87ff72eabf621d0c79b66f3bdd0ecc79e873c1e9f0651ee8bf215c63 \ + --hash=sha256:80e177eff2d1ec172188d0d7fd9694f8e43d3aab76a6f5f929bee7bf7894e98b \ + --hash=sha256:83fcd271567d133eb9532d3b067c8a75be175b2b3b271e2812921a05303a693f \ + --hash=sha256:8ce2e39a40fca82744883834683d833e0eb28623752cc1c21c2ec8f06a890b39 \ + --hash=sha256:96c38cdeef9036eb2724c2210e8d0b93224e709af68c435d46a4733a3675fee1 \ + --hash=sha256:9796732a040f617fc933f9531c9a84bb73c5c27b8074abbe52907076e804b2b7 \ + --hash=sha256:97a090fed480471bb175689859532709e28c085087e344bca45cf318034f70c4 \ + --hash=sha256:9888ceb4faea3116cf02a920ff00bfbc8cc899743e4b4ac914b03625bdc3c300 \ + --hash=sha256:9cc9b901ce129350637426a89cfd650066a4adc6899e47822e2478a74023ff7c \ + --hash=sha256:9e02667f6b9fc1238ba753c0f4b0a37ae184ce8f3bbbc38e115d99646b3f4cd3 \ + --hash=sha256:9e64e98077fb30b6cf98073d6c439cd91deb8ebbf8fc62d9dbf52bd38b0c6ac0 \ + --hash=sha256:9e803d1b1e20240a93bac0bc1025363f7f80cb7eab67dfe21efc0686cc59ad7c \ + --hash=sha256:a05509cfb2059e5d2ddff701d38e474169e9ce2a298cf1b6fd5f3a213a553fe5 \ + --hash=sha256:a20fb1a3974e2dab857870cf874b325b8705605cb7e7e8bcbb915bca896f52a9 \ + --hash=sha256:a5d1cb3f81531f0eb40e13246b679a1bdb58762b170303463cb06ecc296f26d0 \ + --hash=sha256:a600eeb4145fb0ee6c287cb82a2884bd4ec5bbb076921e287039dcc7b7cc6dd0 \ + --hash=sha256:a74714ce836914063c36c8a26ae11383cf8a379698c989fe46883e38a8faa5be \ + --hash=sha256:a7d159e7345f343b44330cbba9194169b8590cb13dae940da47aa36a72aa9929 \ + --hash=sha256:a93e4770ac22794cfa651ee53f092d7de7105c76b9fc088bb81ca0dcf698f704 \ + --hash=sha256:a97200acc6b64ec4cada52c2ecaf1fba1ef9429ce9c542f8a7db5bcaa9dcbd95 \ + --hash=sha256:acb9097213a8dd3410ed9f0dc147840e45ca9797785272928d4be3f0e69e3be4 \ + --hash=sha256:b0304f905efc845829ac2bc791ddebb976db2885f6171f4a3de678d7ee3f7c9f \ + --hash=sha256:b08b61976ffa548bd5349ce54404bf6b2d51bd74d4f1b241ed1b0f25bce09c3a \ + --hash=sha256:b1cac6a4b0252b8811d60b6d8d0f157c0fdfed379ac89c25a914e6346cf355a1 \ + --hash=sha256:b53602371a52b91c80aaf578b5ada29d311d12b8a69c0c17fbc35b76a1fd4f2e \ + --hash=sha256:b74774ca471c86c09b9d5037c8451fff06bb82cd320d26ae5a01c758088c0d5d \ + --hash=sha256:b7cb05bd446687ff816a3aaaf831047fc4c364feff7ada94a66024f1367b448c \ + --hash=sha256:b91387cc0f02a00ac95dcd93f066242d3cca10ff9e6153de7ee07069c6f0f7c8 \ + --hash=sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e \ + --hash=sha256:be7e01f3ad8d0e43954bebdb3088cb466633c2f4acdd88647e7fbfcfe9b9729f \ + --hash=sha256:c18246d88e227a5b16248687514f95642505000442165f4b7db354d39d0e4c29 \ + --hash=sha256:c3736b2a423146b5e62230502e47e08e68282ff3b69bcfe08a322bee73407922 \ + --hash=sha256:c4fb90174d176473122e7eef7c6492d53761826f34ff61c81a1c1d66905025d3 \ + --hash=sha256:c77b3f58a35f20363f6e0a1219b367fbf7e2d2efe3d2c32e1f796447e6061c10 \ + --hash=sha256:cbc388e3d86da1f766d8fc2e12682e446064c01cea9f88a88647cfe7c011de6a \ + --hash=sha256:cdd8aa571b7aa39840fdbea620e308a19691ff595c3a10231e9ee830339dd798 \ + --hash=sha256:cf2727b733e90b4f874bac53e3092aa0413fe1ea6d4f153f01207e6ce65034d9 \ + --hash=sha256:cf555b6299f10a6eb44e4f96d2f5a3884c70ce25dc5c8796aaa2f7b40e72cb1b \ + --hash=sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6 \ + --hash=sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739 \ + --hash=sha256:db0fd964fbd3a9f8999b502f65bd2e20883fdb5b1fae3a424e66db9a793ed307 \ + --hash=sha256:db116850fcf7cca19492030f8d3b4b6e231278e8fe097a043957d22ce1bdf3ee \ + --hash=sha256:de879e9c2eab637f34b1a14c4da1e030c12658cdc69ee1b3e5be81b380163ce5 \ + --hash=sha256:deda9d79d1eb37b688729cac2dba0c137e992ebea960eadb7c2c255524c869e0 \ + --hash=sha256:e7c5bfe4228ea22373e3025965d1a4116097e555ee3436044f5c954a5e63ac45 \ + --hash=sha256:eb440c5644a448e6203935ed60466ec8d0df7278cd22dc6cf782d07911bcbea6 \ + --hash=sha256:f1704c9e041f2b1dc38f5be4552e141e1432fba3dd52c72eeffd5bc2db04dc65 \ + --hash=sha256:f2ae6c3f042fc866cc0fa2bc35ae00d334a9fa56c9d28dfc47d1b4f5ed23e375 \ + --hash=sha256:f6f268caeabb37ccd824d749e7ce0ec6337c4ed954adba33ec0d90cc46b0ab78 \ + --hash=sha256:f8d961bba676e07d77665204f36cffaa260f526e7b32d07ab3df6a2c1dfb44ba \ + --hash=sha256:fcb966a6c57cf07cc9448321a08f3be6b11b7635be502669bc1d8745115d7e7f \ + --hash=sha256:fe5ca35aeec6dc50cabab9bf2d12fbc9067eede7ff4fe92b8f5b99d92e21263f \ + --hash=sha256:ff3c1c32382fb71a200db8bab3df22f32e6ac7ec3170e92fa5b542cf42eed9a2 + # via -r deps/requirements_xpu.txt +six==1.17.0 \ + --hash=sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274 \ + --hash=sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81 + # via oss2 +sniffio==1.3.1 \ + --hash=sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2 \ + --hash=sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc + # via openai +soundfile==0.13.1 \ + --hash=sha256:03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618 \ + --hash=sha256:1e70a05a0626524a69e9f0f4dd2ec174b4e9567f4d8b6c11d38b5c289be36ee9 \ + --hash=sha256:743f12c12c4054921e15736c6be09ac26b3b3d603aef6fd69f9dde68748f2593 \ + --hash=sha256:82dc664d19831933fe59adad199bf3945ad06d84bc111a5b4c0d3089a5b9ec33 \ + --hash=sha256:9c9e855f5a4d06ce4213f31918653ab7de0c5a8d8107cd2427e44b42df547deb \ + --hash=sha256:a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445 \ + --hash=sha256:b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b \ + --hash=sha256:c734564fab7c5ddf8e9be5bf70bab68042cd17e9c214c06e365e20d64f9a69d5 + # via librosa +soxr==1.0.0 \ + --hash=sha256:158a4a9055958c4b95ef91dbbe280cabb00946b5423b25a9b0ce31bd9e0a271e \ + --hash=sha256:1f73f57452f9df37b4de7a4052789fcbd474a5b28f38bba43278ae4b489d4384 \ + --hash=sha256:28e19d74a5ef45c0d7000f3c70ec1719e89077379df2a1215058914d9603d2d8 \ + --hash=sha256:2a3b77b115ae7c478eecdbd060ed4f61beda542dfb70639177ac263aceda42a2 \ + --hash=sha256:38b35c99e408b8f440c9376a5e1dd48014857cd977c117bdaa4304865ae0edd0 \ + --hash=sha256:392a5c70c04eb939c9c176bd6f654dec9a0eaa9ba33d8f1024ed63cf68cdba0a \ + --hash=sha256:3d2a4fadd88207c2991fb08c29fc189e7b2e298b598a94ea1747e42c8acb7a01 \ + --hash=sha256:3f15450e6f65f22f02fcd4c5a9219c873b1e583a73e232805ff160c759a6b586 \ + --hash=sha256:449acd1dfaf10f0ce6dfd75c7e2ef984890df94008765a6742dafb42061c1a24 \ + --hash=sha256:4d3b957a7b0cc19ae6aa45d40b2181474e53a8dd00efd7bce6bcf4e60e020892 \ + --hash=sha256:4e59e5f648bd6144e79a6e0596aa486218876293f5ddce3ca84b9d8f8aa34d6d \ + --hash=sha256:9f417c3d69236051cf5a1a7bad7c4bff04eb3d8fcaa24ac1cb06e26c8d48d8dc \ + --hash=sha256:a39b519acca2364aa726b24a6fd55acf29e4c8909102e0b858c23013c38328e5 \ + --hash=sha256:abecf4e39017f3fadb5e051637c272ae5778d838e5c3926a35db36a53e3a607f \ + --hash=sha256:b876a3156f67c76aef0cff1084eaf4088d9ca584bb569cb993f89a52ec5f399f \ + --hash=sha256:b89685faedebc45af71f08f9957b61cc6143bc94ba43fe38e97067f81e272969 \ + --hash=sha256:bb86c342862697dbd4a44043f275e5196f2d2c49dca374c78f19b7893988675d \ + --hash=sha256:c120775b7d0ef9e974a5797a4695861e88653f7ecd0a2a532f089bc4452ba130 \ + --hash=sha256:c7f5ace8f04f924b21caedeeb69f2a7b3d83d2d436639498c08b2cebe181af14 \ + --hash=sha256:d255741b2f0084fd02d4a2ddd77cd495be9e7e7b6f9dba1c9494f86afefac65b \ + --hash=sha256:e07ee6c1d659bc6957034f4800c60cb8b98de798823e34d2a2bba1caa85a4509 \ + --hash=sha256:e8ce273cca101aff3d8c387db5a5a41001ba76ef1837883438d3c652507a9ccc \ + --hash=sha256:e8f2a69686f2856d37823bbb7b78c3d44904f311fe70ba49b893af11d6b6047b \ + --hash=sha256:e973d487ee46aa8023ca00a139db6e09af053a37a032fe22f9ff0cc2e19c94b4 \ + --hash=sha256:f8dc69fc18884e53b72f6141fdf9d80997edbb4fec9dc2942edcb63abbe0d023 \ + --hash=sha256:fdc41a1027ba46777186f26a8fba7893be913383414135577522da2fcc684490 + # via librosa +starlette==0.52.1 \ + --hash=sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74 \ + --hash=sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933 + # via fastapi +sympy==1.14.0 \ + --hash=sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517 \ + --hash=sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5 + # via + # -r deps/requirements_xpu.txt + # torch +tbb==2022.3.0 \ + --hash=sha256:a7e122cb98a6f8823940341aa323dcdfffa77e36712a22a1ae3a76430fa9f412 \ + --hash=sha256:bb893f5772855ff2fd21867cb5c2806cb7d2960a178e660b342bc6a706a6ebf4 + # via + # intel-opencl-rt + # mkl + # torch +tcmlib==1.4.1 \ + --hash=sha256:0d5bd98db48d31bec7fedba5c23599bf9ae43c7016d4c3946d25242d320cee89 \ + --hash=sha256:5202a1fd8541182fbd4ef72848784e4bf94340152d7ddff33d401d30930fa53c + # via + # tbb + # torch + # umf +threadpoolctl==3.6.0 \ + --hash=sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb \ + --hash=sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e + # via scikit-learn +thrift==0.22.0 \ + --hash=sha256:42e8276afbd5f54fe1d364858b6877bc5e5a4a5ed69f6a005b94ca4918fe1466 + # via -r deps/requirements_xpu.txt +tiktoken==0.12.0 \ + --hash=sha256:01d99484dc93b129cd0964f9d34eee953f2737301f18b3c7257bf368d7615baa \ + --hash=sha256:04f0e6a985d95913cabc96a741c5ffec525a2c72e9df086ff17ebe35985c800e \ + --hash=sha256:06a9f4f49884139013b138920a4c393aa6556b2f8f536345f11819389c703ebb \ + --hash=sha256:09eb4eae62ae7e4c62364d9ec3a57c62eea707ac9a2b2c5d6bd05de6724ea179 \ + --hash=sha256:0ee8f9ae00c41770b5f9b0bb1235474768884ae157de3beb5439ca0fd70f3e25 \ + --hash=sha256:15d875454bbaa3728be39880ddd11a5a2a9e548c29418b41e8fd8a767172b5ec \ + --hash=sha256:20cf97135c9a50de0b157879c3c4accbb29116bcf001283d26e073ff3b345946 \ + --hash=sha256:285ba9d73ea0d6171e7f9407039a290ca77efcdb026be7769dccc01d2c8d7fff \ + --hash=sha256:2b90f5ad190a4bb7c3eb30c5fa32e1e182ca1ca79f05e49b448438c3e225a49b \ + --hash=sha256:2cff3688ba3c639ebe816f8d58ffbbb0aa7433e23e08ab1cade5d175fc973fb3 \ + --hash=sha256:35a2f8ddd3824608b3d650a000c1ef71f730d0c56486845705a8248da00f9fe5 \ + --hash=sha256:399c3dd672a6406719d84442299a490420b458c44d3ae65516302a99675888f3 \ + --hash=sha256:3de02f5a491cfd179aec916eddb70331814bd6bf764075d39e21d5862e533970 \ + --hash=sha256:3e68e3e593637b53e56f7237be560f7a394451cb8c11079755e80ae64b9e6def \ + --hash=sha256:47a5bc270b8c3db00bb46ece01ef34ad050e364b51d406b6f9730b64ac28eded \ + --hash=sha256:4a1a4fcd021f022bfc81904a911d3df0f6543b9e7627b51411da75ff2fe7a1be \ + --hash=sha256:4c9614597ac94bb294544345ad8cf30dac2129c05e2db8dc53e082f355857af7 \ + --hash=sha256:508fa71810c0efdcd1b898fda574889ee62852989f7c1667414736bcb2b9a4bd \ + --hash=sha256:54c891b416a0e36b8e2045b12b33dd66fb34a4fe7965565f1b482da50da3e86a \ + --hash=sha256:584c3ad3d0c74f5269906eb8a659c8bfc6144a52895d9261cdaf90a0ae5f4de0 \ + --hash=sha256:5edb8743b88d5be814b1a8a8854494719080c28faaa1ccbef02e87354fe71ef0 \ + --hash=sha256:604831189bd05480f2b885ecd2d1986dc7686f609de48208ebbbddeea071fc0b \ + --hash=sha256:65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37 \ + --hash=sha256:6de0da39f605992649b9cfa6f84071e3f9ef2cec458d08c5feb1b6f0ff62e134 \ + --hash=sha256:6e227c7f96925003487c33b1b32265fad2fbcec2b7cf4817afb76d416f40f6bb \ + --hash=sha256:6faa0534e0eefbcafaccb75927a4a380463a2eaa7e26000f0173b920e98b720a \ + --hash=sha256:6fb2995b487c2e31acf0a9e17647e3b242235a20832642bb7a9d1a181c0c1bb1 \ + --hash=sha256:775c2c55de2310cc1bc9a3ad8826761cbdc87770e586fd7b6da7d4589e13dab3 \ + --hash=sha256:82991e04fc860afb933efb63957affc7ad54f83e2216fe7d319007dab1ba5892 \ + --hash=sha256:83d16643edb7fa2c99eff2ab7733508aae1eebb03d5dfc46f5565862810f24e3 \ + --hash=sha256:8f317e8530bb3a222547b85a58583238c8f74fd7a7408305f9f63246d1a0958b \ + --hash=sha256:981a81e39812d57031efdc9ec59fa32b2a5a5524d20d4776574c4b4bd2e9014a \ + --hash=sha256:9baf52f84a3f42eef3ff4e754a0db79a13a27921b457ca9832cf944c6be4f8f3 \ + --hash=sha256:a01b12f69052fbe4b080a2cfb867c4de12c704b56178edf1d1d7b273561db160 \ + --hash=sha256:a1af81a6c44f008cba48494089dd98cccb8b313f55e961a52f5b222d1e507967 \ + --hash=sha256:a90388128df3b3abeb2bfd1895b0681412a8d7dc644142519e6f0a97c2111646 \ + --hash=sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931 \ + --hash=sha256:b4e7ed1c6a7a8a60a3230965bdedba8cc58f68926b835e519341413370e0399a \ + --hash=sha256:b6cfb6d9b7b54d20af21a912bfe63a2727d9cfa8fbda642fd8322c70340aad16 \ + --hash=sha256:b8a0cd0c789a61f31bf44851defbd609e8dd1e2c8589c614cc1060940ef1f697 \ + --hash=sha256:b97f74aca0d78a1ff21b8cd9e9925714c15a9236d6ceacf5c7327c117e6e21e8 \ + --hash=sha256:c06cf0fcc24c2cb2adb5e185c7082a82cba29c17575e828518c2f11a01f445aa \ + --hash=sha256:c2c714c72bc00a38ca969dae79e8266ddec999c7ceccd603cc4f0d04ccd76365 \ + --hash=sha256:cbb9a3ba275165a2cb0f9a83f5d7025afe6b9d0ab01a22b50f0e74fee2ad253e \ + --hash=sha256:cde24cdb1b8a08368f709124f15b36ab5524aac5fa830cc3fdce9c03d4fb8030 \ + --hash=sha256:d186a5c60c6a0213f04a7a802264083dea1bbde92a2d4c7069e1a56630aef830 \ + --hash=sha256:d51d75a5bffbf26f86554d28e78bfb921eae998edc2675650fd04c7e1f0cdc1e \ + --hash=sha256:d5f89ea5680066b68bcb797ae85219c72916c922ef0fcdd3480c7d2315ffff16 \ + --hash=sha256:da900aa0ad52247d8794e307d6446bd3cdea8e192769b56276695d34d2c9aa88 \ + --hash=sha256:dc2dd125a62cb2b3d858484d6c614d136b5b848976794edfb63688d539b8b93f \ + --hash=sha256:df37684ace87d10895acb44b7f447d4700349b12197a526da0d4a4149fde074c \ + --hash=sha256:dfdfaa5ffff8993a3af94d1125870b1d27aed7cb97aa7eb8c1cefdbc87dbee63 \ + --hash=sha256:edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad \ + --hash=sha256:f18f249b041851954217e9fd8e5c00b024ab2315ffda5ed77665a05fa91f42dc \ + --hash=sha256:f61c0aea5565ac82e2ec50a05e02a6c44734e91b51c10510b084ea1b8e633a71 \ + --hash=sha256:fc530a28591a2d74bce821d10b418b26a094bf33839e69042a6e86ddb7a7fb27 \ + --hash=sha256:ffc5288f34a8bc02e1ea7047b8d041104791d2ddbf42d1e5fa07822cbffe16bd + # via -r deps/requirements_xpu.txt +timm==1.0.26 \ + --hash=sha256:985c330de5ccc3a2aa0224eb7272e6a336084702390bb7e3801f3c91603d3683 \ + --hash=sha256:f66f082f2f381cf68431c22714c8b70f723837fa2a185b155961eab90f2d5b10 + # via -r deps/requirements_xpu.txt +tokenizers==0.22.2 \ + --hash=sha256:143b999bdc46d10febb15cbffb4207ddd1f410e2c755857b5a0797961bbdc113 \ + --hash=sha256:1a62ba2c5faa2dd175aaeed7b15abf18d20266189fb3406c5d0550dd34dd5f37 \ + --hash=sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e \ + --hash=sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001 \ + --hash=sha256:1e50f8554d504f617d9e9d6e4c2c2884a12b388a97c5c77f0bc6cf4cd032feee \ + --hash=sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7 \ + --hash=sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd \ + --hash=sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4 \ + --hash=sha256:319f659ee992222f04e58f84cbf407cfa66a65fe3a8de44e8ad2bc53e7d99012 \ + --hash=sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67 \ + --hash=sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a \ + --hash=sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5 \ + --hash=sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917 \ + --hash=sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c \ + --hash=sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195 \ + --hash=sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4 \ + --hash=sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a \ + --hash=sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc \ + --hash=sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92 \ + --hash=sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5 \ + --hash=sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48 \ + --hash=sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b \ + --hash=sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c \ + --hash=sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5 + # via transformers +torch==2.10.0+xpu \ + --hash=sha256:28dd7f7c2e06f78d63583629f5387b29fae24ae3180846a6f59218b0f37cc079 \ + --hash=sha256:2b4b56dd6c792aef82006904fa888692e3782e4ae5da27526801bad4898f05a5 \ + --hash=sha256:34937622124a3412beaa98b32f261c1cb56764613072ffc343f4da1b3420ed7f \ + --hash=sha256:3ad605be4728b6d3a28a44d07dd794b1a9e45551b0057815bf25eb2a6d6a56a7 \ + --hash=sha256:3bc64a746ff25a93de140902c60c9e819d7413f5cea1e88d80999c27a5901e9c \ + --hash=sha256:5979758de3e0563896bbf045a5dfbc36bff440f5fe669d8a5e71869013f0a802 \ + --hash=sha256:5eda78bd60f8e93d570b078d28fa6319b227ee05cd8ceb4eddf6366aee62029e \ + --hash=sha256:71ad2f82da0f41eaec159f39fc85854e27c2391efa91b373e550648a6f4aaad3 \ + --hash=sha256:aa90a6d0eef8baa037d5a3de8d4eb132701b71594eb3a4e5d24aadabb49fe3b8 \ + --hash=sha256:abb1d1ec1ac672bac0ff35420c965f2df0c636ef9d94e2a830e34578489d0a57 \ + --hash=sha256:b473571d478912f92881cc13f15fa18f8463fb0fb8a068c96ed47a7d45a4da0a \ + --hash=sha256:cb9d37f21cb9fb7df67d62863f021c3144e8d8832b9ea8e8523ac308bc620ea1 \ + --hash=sha256:ce50691ab3fb6301d9b7bb8b3834cf5fa7152a2b5f91fd24c5efdc601a25b780 \ + --hash=sha256:e0536d112fe04deee60897de1f92f2705d129ce19ac9a98d5947877adf5d8e4c + # via + # -r deps/requirements_xpu.txt + # sentence-transformers + # timm + # torchvision +torchvision==0.25.0+xpu \ + --hash=sha256:0f4d53af8f3e84e42ea7048cdff410a0b97eabb8cdc4c2e8c86a9acdaa69ffea \ + --hash=sha256:1c4b44b36a557f7381e3076fb8843366742238648441d607c8d049c6da0f8886 \ + --hash=sha256:216ad249333993ed128368f996210cc9ceae3b4d15709b25aadba844d6c6e8b7 \ + --hash=sha256:36cbaedf10f6412af5c89afd9aeea474e6a56a0050348ada8fabe1ecaf6b879e \ + --hash=sha256:6ad2543496bc29e59d3dd614a94d09aa9870318aedb66045344fffddfedd2cf8 \ + --hash=sha256:6b9485ba85dcba4d196d6134d9c3332fb228fb2556416bf0450a64e8a472fcba \ + --hash=sha256:738357d97468d75fe3d510ac37e65130f2787f81d9bbc1518898f7396dc3403f \ + --hash=sha256:7a04beba6859b76e9e010f2f0eccf13ce70ff5942944a552e83844c166051515 \ + --hash=sha256:7e1e7b170fcf7161c8499b67156c5a05462243626dc0974010791a0bab4378d3 \ + --hash=sha256:80269f37865fcd8b57f20e4786efae2200bfa2b2727926c3c7acc82f0e7d3548 \ + --hash=sha256:b09bc9ef446628e6863ca685a8c75af31cd8e958a892b6e7abd7e690452ac608 \ + --hash=sha256:bd6add201bd7628af70437292e1447abb368e0b5f4ff9abd334ae435efd44792 \ + --hash=sha256:dfe2bcac32b9cfdd1f6dd6656579f22c1f73e6433c02b91928685060d5d0290f \ + --hash=sha256:fcaa0c1d268f741adedd28be4825b237a67c4bc1ef62f60ef497e806f5542b19 + # via + # -r deps/requirements_xpu.txt + # timm +tqdm==4.67.3 \ + --hash=sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb \ + --hash=sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf + # via + # huggingface-hub + # openai + # sentence-transformers + # transformers +transformers==4.57.6 \ + --hash=sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550 \ + --hash=sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3 + # via + # -r deps/requirements_xpu.txt + # sentence-transformers +triton-xpu==3.6.0 \ + --hash=sha256:17a42ee5c47e73d40e8ec67c064c4441104b7c73e3aaebaa5981e98c9087bb4e \ + --hash=sha256:1d4494e959b32ec78ce0dfc389cf68046433624aa7153b4e73dd313431c23c0e \ + --hash=sha256:28f0d5a1ea08dc13f967f4aa31702cb08b561437aaac195f2eb7100721cb5d7f \ + --hash=sha256:35909d70c04a8608f17a6213ef24a1c4957a64027cc5c3c374ea85b23e90f094 \ + --hash=sha256:4341e829e54a778ea9d71593bb967d8df4a840e15d247194607ac4d85a516bb8 \ + --hash=sha256:58cd73166fb88c890d3f7e53c9ab252541614faca0709e89bb5e5c61e363c20c \ + --hash=sha256:609d331da7ba3a609fc4cee0f0a25dbaacb7f47a8a3022217324d96e9dcb350e \ + --hash=sha256:6f68b4193109900080e88f08ee35d5fe27dba0cf7504ebbeec74bfeac066ac95 \ + --hash=sha256:7ba9de96e5d36400b996b9fb9eb38443196453aefc11fafe1a7bb226bc5fb8bb \ + --hash=sha256:a27f6cda990fab4e3fd8064bb44b9e87fe80d8f1c650f0442fb4d793bcd72968 \ + --hash=sha256:a58c9cc87602a12456217d792e3a9739f651971d667f55c1294a8337e7a43412 \ + --hash=sha256:d133d858d4f2a51f26f36662023ad6efcbfb4b4919b3f15b1fbdfb71cb77700c \ + --hash=sha256:ea6bdf88f781e12fcd8c0c21ad8b5753282a2e8220e95203138aadf52388330c \ + --hash=sha256:ef733f3dd2a0aa5d33cf8af6f34ea4e1614f3189fe7d76a920f4b1a15d1eee09 + # via torch +typing-extensions==4.15.0 \ + --hash=sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466 \ + --hash=sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548 + # via + # -r deps/requirements_xpu.txt + # aiosignal + # anyio + # fastapi + # grpcio + # huggingface-hub + # librosa + # openai + # pydantic + # pydantic-core + # starlette + # torch + # typing-inspection +typing-inspection==0.4.2 \ + --hash=sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7 \ + --hash=sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464 + # via + # fastapi + # pydantic +umf==1.0.2 \ + --hash=sha256:695b6be076a7bd2037b0cdbe5ee025f9ae74934cc78bdf25df8b52e8f746e457 \ + --hash=sha256:ef4d144a2007a73a1a22ee575ee4f5a1894a206532c6f6d77b4cf548643502fb + # via + # intel-cmplr-lib-ur + # torch +urllib3==2.6.3 \ + --hash=sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed \ + --hash=sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4 + # via requests +uvicorn==0.42.0 \ + --hash=sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359 \ + --hash=sha256:9b1f190ce15a2dd22e7758651d9b6d12df09a13d51ba5bf4fc33c383a48e1775 + # via -r deps/requirements_xpu.txt +wcwidth==0.6.0 \ + --hash=sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad \ + --hash=sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159 + # via prettytable +websocket-client==1.9.0 \ + --hash=sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98 \ + --hash=sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef + # via dashscope +yarl==1.23.0 \ + --hash=sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc \ + --hash=sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4 \ + --hash=sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85 \ + --hash=sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993 \ + --hash=sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222 \ + --hash=sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de \ + --hash=sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25 \ + --hash=sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e \ + --hash=sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2 \ + --hash=sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e \ + --hash=sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860 \ + --hash=sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957 \ + --hash=sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760 \ + --hash=sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52 \ + --hash=sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788 \ + --hash=sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912 \ + --hash=sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719 \ + --hash=sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035 \ + --hash=sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220 \ + --hash=sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412 \ + --hash=sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05 \ + --hash=sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41 \ + --hash=sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4 \ + --hash=sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4 \ + --hash=sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd \ + --hash=sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748 \ + --hash=sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a \ + --hash=sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4 \ + --hash=sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34 \ + --hash=sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069 \ + --hash=sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25 \ + --hash=sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2 \ + --hash=sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb \ + --hash=sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f \ + --hash=sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5 \ + --hash=sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8 \ + --hash=sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c \ + --hash=sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512 \ + --hash=sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6 \ + --hash=sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5 \ + --hash=sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9 \ + --hash=sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072 \ + --hash=sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5 \ + --hash=sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277 \ + --hash=sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a \ + --hash=sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6 \ + --hash=sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae \ + --hash=sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26 \ + --hash=sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2 \ + --hash=sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4 \ + --hash=sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70 \ + --hash=sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723 \ + --hash=sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c \ + --hash=sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9 \ + --hash=sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5 \ + --hash=sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e \ + --hash=sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c \ + --hash=sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4 \ + --hash=sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0 \ + --hash=sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2 \ + --hash=sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b \ + --hash=sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7 \ + --hash=sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750 \ + --hash=sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2 \ + --hash=sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474 \ + --hash=sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716 \ + --hash=sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7 \ + --hash=sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123 \ + --hash=sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007 \ + --hash=sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595 \ + --hash=sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe \ + --hash=sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea \ + --hash=sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598 \ + --hash=sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679 \ + --hash=sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8 \ + --hash=sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83 \ + --hash=sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6 \ + --hash=sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f \ + --hash=sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94 \ + --hash=sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51 \ + --hash=sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120 \ + --hash=sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039 \ + --hash=sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1 \ + --hash=sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05 \ + --hash=sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb \ + --hash=sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144 \ + --hash=sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa \ + --hash=sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a \ + --hash=sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99 \ + --hash=sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928 \ + --hash=sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d \ + --hash=sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3 \ + --hash=sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434 \ + --hash=sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86 \ + --hash=sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46 \ + --hash=sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319 \ + --hash=sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67 \ + --hash=sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c \ + --hash=sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169 \ + --hash=sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c \ + --hash=sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59 \ + --hash=sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107 \ + --hash=sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4 \ + --hash=sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a \ + --hash=sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb \ + --hash=sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f \ + --hash=sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769 \ + --hash=sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432 \ + --hash=sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090 \ + --hash=sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764 \ + --hash=sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d \ + --hash=sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4 \ + --hash=sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b \ + --hash=sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d \ + --hash=sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543 \ + --hash=sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24 \ + --hash=sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5 \ + --hash=sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b \ + --hash=sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d \ + --hash=sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b \ + --hash=sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6 \ + --hash=sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735 \ + --hash=sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e \ + --hash=sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28 \ + --hash=sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3 \ + --hash=sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401 \ + --hash=sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6 \ + --hash=sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d + # via aiohttp +zipp==3.23.0 \ + --hash=sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e \ + --hash=sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166 + # via importlib-metadata + +# The following packages are considered to be unsafe in a requirements file: +setuptools==82.0.1 \ + --hash=sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9 \ + --hash=sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb + # via + # -r deps/requirements_xpu.txt + # grpcio-tools + # torch diff --git a/deps/requirements_xpu.txt b/deps/requirements_xpu.txt new file mode 100644 index 0000000000..08a34d27f9 --- /dev/null +++ b/deps/requirements_xpu.txt @@ -0,0 +1,73 @@ +# Standalone XPU requirements — does NOT inherit requirements_base.txt. +# Packages that are CUDA-only (bitsandbytes, cpm_kernels, pynvml, auto_gptq, +# autoawq, tensorrt*, flash_attn, flashinfer*, deep_gemm, deep_ep, nvidia-*, +# xfastertransformer*, decord, onnx) are deliberately excluded. +# +# Install with: +# pip install -r deps/requirements_xpu.txt \ +# --extra-index-url https://download.pytorch.org/whl/xpu + +# ---------- Pin torch/torchvision to prevent CUDA upgrade ---------- +# These must already be installed from the XPU index. Pinning here stops +# pip from pulling the generic (CUDA) torch when resolving transitive deps. +torch==2.10.0+xpu +torchvision==0.25.0+xpu + +# ---------- Server framework ---------- +fastapi>=0.115.6 +uvicorn>=0.30.0 +grpcio==1.78.0 +grpcio-tools==1.78.0 +protobuf>=4.25 + +# ---------- Model loading ---------- +transformers==4.57.6 +safetensors>=0.7.0 +sentencepiece>=0.2.0 +tiktoken>=0.7.0 +einops +librosa + +# ---------- Core utilities ---------- +numpy<2.0a0,>=1.25 +pydantic>=2.0 +requests +jinja2 +orjson +sympy +psutil +pyyaml +filelock>=3.20.0 +setproctitle +nest_asyncio +typing-extensions +importlib_metadata +setuptools>=60.5.0 + +# ---------- Application / API ---------- +aiohttp +concurrent_log_handler +dacite +dashscope>=1.11.0 +json5 +lru-dict +openai +partial_json_parser +Pillow +pillow-avif-plugin>=1.5.2 +pillow-heif +portalocker +oss2 +prettytable +timm + +# ---------- Misc ---------- +jieba +sentence-transformers==2.7.0 +pybind11_stubgen +py-spy +thrift +# vllm-xpu-kernels is installed separately from a custom index or source +# build; not included in pip-compile resolution since it is not on PyPI +# or the standard PyTorch XPU wheel index. +# Install manually: pip install vllm-xpu-kernels --find-links diff --git a/rtp_llm/BUILD b/rtp_llm/BUILD index 759e7dd621..3519e6df37 100755 --- a/rtp_llm/BUILD +++ b/rtp_llm/BUILD @@ -2,7 +2,7 @@ package(default_visibility = ["//visibility:public"]) load("@rules_python//python:packaging.bzl", "py_package", "py_wheel") # make different torch for different device when in compiling load("//bazel:defs.bzl", "upload_pkg", "copy_target_to", "upload_wheel", "rename_wheel", "rename_wheel_aarch64") -load("@arch_config//:arch_select.bzl", "requirement", "whl_deps", "internal_deps", "jit_deps", "triton_deps", "platform_deps") +load("@arch_config//:arch_select.bzl", "requirement", "whl_deps", "internal_deps", "jit_deps", "triton_deps", "platform_deps", "filter_xpu_whl_reqs") load("//bazel:bundle.bzl", "bundle_files", "bundle_tar") load("@release_version//:defs.bzl", "RELEASE_VERSION") @@ -62,12 +62,14 @@ xft_dep = select({ arch_dep = select({ "@//:using_arm": [], "@//:using_cuda12_arm": [], + "@//:using_xpu": [], "//conditions:default": [":decord", ":av"], }) arch_with_version_dep = select({ "@//:using_arm": [], "@//:using_cuda12_arm": [], + "@//:using_xpu": [], "//conditions:default": ["decord==0.6.0", "av==16.1.0"], }) @@ -565,7 +567,7 @@ py_package( }), ) -whl_reqs = [ +_whl_reqs_static = [ "filelock>=3.20.0", "jinja2", "sympy", @@ -619,7 +621,9 @@ whl_reqs = [ "portalocker", "concurrent_log_handler", "apache-tvm-ffi", -] + whl_deps() + platform_deps() + xft_dep +] + +whl_reqs = filter_xpu_whl_reqs(_whl_reqs_static) + whl_deps() + platform_deps() + xft_dep py_wheel( name = "rtp_llm_frontend_whl", @@ -709,6 +713,16 @@ rename_wheel( src = ":rtp_llm_whl", ) +# XPU wheels are built with the Python 3.12 interpreter (PyTorch XPU requires +# ==3.12), so they must carry the cp312 tag instead of the default cp310 that +# the CUDA/ROCm (Python 3.10) builds use. Build this target under --config=xpu. +rename_wheel( + name = "rtp_llm_xpu", + package_name = "rtp_llm-%s" % RELEASE_VERSION, + src = ":rtp_llm_whl", + python_tag = "cp312", +) + rename_wheel( name = "rtp_llm_cuda12", package_name = "rtp_llm-%s+cuda121" % RELEASE_VERSION, diff --git a/rtp_llm/config/server_config_setup.py b/rtp_llm/config/server_config_setup.py index 488d21f68a..cc54dbb4cc 100644 --- a/rtp_llm/config/server_config_setup.py +++ b/rtp_llm/config/server_config_setup.py @@ -265,10 +265,9 @@ def set_parallelism_config( world_size = parallelism_config.world_size need_local = world_size > 1 and parallelism_config.local_world_size == 1 if need_local: - if torch.cuda.is_available(): - n = min(torch.cuda.device_count(), world_size) - else: - n = world_size + from rtp_llm.device.device_impl import gpu_device_count + dev_count = gpu_device_count() + n = min(dev_count, world_size) if dev_count > 0 else world_size parallelism_config.local_world_size = max(n, 1) # Resolve and validate parallelism configuration. @@ -409,19 +408,55 @@ def setup_default_args(py_env_configs): logging.info( "[MI308X] set SEQ_SIZE_PER_BLOCK 16 by default, as it just support 16 now." ) - if ( - os.path.exists("/dev/alixpu") - and py_env_configs.kv_cache_config.seq_size_per_block == 0 - ): - py_env_configs.kv_cache_config.seq_size_per_block = 256 - logging.info("set SEQ_SIZE_PER_BLOCK 256 by default") + if py_env_configs.kv_cache_config.seq_size_per_block == 0: + from rtp_llm.device.device_impl import _is_xpu_device + + if _is_xpu_device(): + # Robust XPU detection (torch.xpu) instead of relying solely on the + # container device node, which may move/disappear. The page size + # depends on the XPU attention backend, not just "is it XPU": + # * Ali XPU custom attention supports 256. + # * Generic Intel XPU uses the vllm fmha kernel, which rejects 256 + # ("Unsupported page size for fmha") and needs <= 64. + # Resolve via an explicit, logged decision (never a silent fallback): + # 1) XPU_SEQ_SIZE_PER_BLOCK env override, if set. + # 2) Ali XPU hardware signal (/dev/alixpu device node) -> 256. + # 3) Safe default for generic Intel XPU -> 64. + xpu_override = os.environ.get("XPU_SEQ_SIZE_PER_BLOCK") + if xpu_override: + try: + seq_size = int(xpu_override) + except ValueError: + raise ValueError( + "XPU_SEQ_SIZE_PER_BLOCK must be a positive integer, " + f"got {xpu_override!r}") + if seq_size <= 0 or (seq_size & (seq_size - 1)) != 0: + raise ValueError( + "XPU_SEQ_SIZE_PER_BLOCK must be a positive power of two " + "(e.g. 64 for generic Intel XPU, 256 for Ali XPU), " + f"got {seq_size}") + logging.info( + "set SEQ_SIZE_PER_BLOCK %d from XPU_SEQ_SIZE_PER_BLOCK", seq_size) + elif os.path.exists("/dev/alixpu"): + seq_size = 256 + logging.info( + "set SEQ_SIZE_PER_BLOCK 256 for Ali XPU (custom attention)") + else: + seq_size = 64 + logging.info( + "set SEQ_SIZE_PER_BLOCK 64 for generic Intel XPU " + "(vllm fmha does not support 256); override with " + "XPU_SEQ_SIZE_PER_BLOCK if your backend supports a larger page") + py_env_configs.kv_cache_config.seq_size_per_block = seq_size + if py_env_configs.kv_cache_config.seq_size_per_block == 0: py_env_configs.kv_cache_config.seq_size_per_block = 64 # Set NCCL_P2P_DISABLE for RTX GPUs or when CUDA is not available # Frontend doesn't need this setting if py_env_configs.role_config.role_type != RoleType.FRONTEND: - if torch.cuda.is_available(): + from rtp_llm.device.device_impl import _is_cuda_device + if _is_cuda_device(): if ( "NCCL_P2P_DISABLE" not in os.environ and "RTX" in torch.cuda.get_device_name(0) @@ -512,9 +547,12 @@ def fetch_model_files_to_local(py_env_configs: PyEnvConfigs): def setup_cuda_device_and_accl_env(local_rank: int) -> None: - """Apply CUDA device and ACCL env side effects (same as ParallelInfo.from_params).""" - if torch.cuda.is_available(): - torch.cuda.set_device(local_rank) + """Apply CUDA/XPU device and ACCL env side effects (same as ParallelInfo.from_params).""" + # Route through gpu_set_device so an explicit RTP_LLM_DEVICE_TYPE override + # (e.g. cuda/rocm/ppu on a mixed XPU+CUDA host) is honored instead of + # unconditionally preferring XPU when torch.xpu happens to be available. + from rtp_llm.device.device_impl import gpu_set_device + gpu_set_device(local_rank) if os.environ.get("ACCL_SELECT_PATH") == "1": select_port = str(local_rank % 2) @@ -553,6 +591,14 @@ def setup_and_configure_server(py_env_configs: PyEnvConfigs): py_env_configs: PyEnvConfigs object to configure """ setup_default_args(py_env_configs) + # Fail-fast: reject unsupported XPU configurations before downloading model files. + if py_env_configs.sp_config.type != SpeculativeType.NONE: + from rtp_llm.device.device_impl import _is_xpu_device + if _is_xpu_device(): + raise ValueError( + "Speculative decoding is not supported on XPU. " + "Disable speculative decoding (sp_config.type = NONE) " + "when running on Intel GPU.") fetch_model_files_to_local(py_env_configs) ll_num_max_token = py_env_configs.concurrency_config.concurrency_limit sp_type = py_env_configs.sp_config.type # Get SpeculativeType enum value diff --git a/rtp_llm/cpp/cache/BlockInfo.h b/rtp_llm/cpp/cache/BlockInfo.h index 3770cb04b9..8e0210d9b5 100644 --- a/rtp_llm/cpp/cache/BlockInfo.h +++ b/rtp_llm/cpp/cache/BlockInfo.h @@ -11,9 +11,15 @@ namespace rtp_llm { // This header is intentionally kept dependency-free so low-level transfer modules // (e.g. rtp_llm::transfer::tcp) can include it without pulling in engine_base/stream. struct BlockInfo { - // Torch device of the backing storage (CPU/CUDA), taken from the underlying tensor. - // Kept as raw values to avoid torch->rtp conversions inside cache. - bool is_cuda = false; + // is_cuda: true when the backing storage is on an accelerator device + // (CUDA or XPU), false when on host/CPU memory. Despite the name, this is + // NOT CUDA-specific -- XPU blocks also set it to true. Taken from the + // underlying tensor and kept as raw values to avoid torch->rtp conversions + // inside cache. + // TODO(xpu) [MUST-DO next iteration]: rename is_cuda -> is_device_memory + // (or is_accelerator) and update all read/write sites. Deferred here to + // keep this PR low-risk; the name is misleading for non-CUDA accelerators. + bool is_cuda = false; int32_t device_index = 0; int32_t scalar_type = 0; // c10::ScalarType diff --git a/rtp_llm/cpp/cache/BlockPool.cc b/rtp_llm/cpp/cache/BlockPool.cc index c7a94322ea..f9d30a2705 100644 --- a/rtp_llm/cpp/cache/BlockPool.cc +++ b/rtp_llm/cpp/cache/BlockPool.cc @@ -38,12 +38,18 @@ void BlockPool::validateConfig() const { void BlockPool::initializeCacheBuffer() { if (allocation_type_ == AllocationType::HOST) { - cache_aligned_buffer_ = torch::empty({static_cast(config_.total_size_bytes)}, - torch::TensorOptions().dtype(torch::kUInt8).device(torch::kCPU)) - .pin_memory(); + auto host_buffer = torch::empty({static_cast(config_.total_size_bytes)}, + torch::TensorOptions().dtype(torch::kUInt8).device(torch::kCPU)); +#if USING_XPU + // XPU has no CUDA-style host-pinned memory; keep a plain pageable CPU + // buffer to avoid a no-op / failing pin_memory() call. + cache_aligned_buffer_ = host_buffer; +#else + cache_aligned_buffer_ = host_buffer.pin_memory(); +#endif } else { cache_aligned_buffer_ = torch::empty({static_cast(config_.total_size_bytes)}, - torch::TensorOptions().dtype(torch::kUInt8).device(torch::kCUDA)); + torch::TensorOptions().dtype(torch::kUInt8).device(getTorchDevice())); } cache_base_ptr_ = cache_aligned_buffer_.data_ptr(); RTP_LLM_CHECK_WITH_INFO(cache_base_ptr_ != nullptr, "block pool allocate cache aligned buffer is null"); @@ -500,7 +506,7 @@ BlockPool::convertIndexToBuffer(int layer_id, int block_id, int partition_count, } MemoryType BlockPool::where() const { - return cache_aligned_buffer_.is_cuda() ? MemoryType::MEMORY_GPU : MemoryType::MEMORY_CPU; + return (cache_aligned_buffer_.is_cuda() || cache_aligned_buffer_.is_xpu()) ? MemoryType::MEMORY_GPU : MemoryType::MEMORY_CPU; } void BlockPool::checkLayoutValidity(int layout_id) const { diff --git a/rtp_llm/cpp/cache/KVCacheManager.cc b/rtp_llm/cpp/cache/KVCacheManager.cc index ce9b4840c6..bdcb46eec4 100644 --- a/rtp_llm/cpp/cache/KVCacheManager.cc +++ b/rtp_llm/cpp/cache/KVCacheManager.cc @@ -17,6 +17,7 @@ namespace rtp_llm { + KVCacheManager::KVCacheManager(const CacheConfig& config, bool warmup, const kmonitor::MetricsReporterPtr metrics_reporter, @@ -190,8 +191,8 @@ bool KVCacheManager::setKVBlockValue(int block_index, } auto* dst_ptr = static_cast(dst_block.addr) + dst_byte_offset; - auto dst_device = dst_block.is_cuda ? torch::kCUDA : torch::kCPU; - auto src_device = src_tensor.is_cuda() ? torch::kCUDA : torch::kCPU; + auto dst_device = dst_block.is_cuda ? getTorchDevice() : torch::kCPU; + auto src_device = (src_tensor.is_cuda() || src_tensor.is_xpu()) ? getTorchDevice() : torch::kCPU; auto dst_t = torch::from_blob( dst_ptr, {(int64_t)src_bytes}, torch::TensorOptions().dtype(torch::kUInt8).device(dst_device)); auto src_t = torch::from_blob(src_tensor.data_ptr(), @@ -492,7 +493,7 @@ void KVCacheManager::allocateAndSync() { size_t world_size = parallelism_config_.tp_size * parallelism_config_.dp_size; if (world_size > 1) { size_t local_rank = parallelism_config_.tp_size * parallelism_config_.dp_rank + parallelism_config_.tp_rank; - auto block_num_t = torch::empty({(int64_t)world_size}, torch::kInt32).pin_memory(); + auto block_num_t = maybePinMemory(torch::empty({(int64_t)world_size}, torch::kInt32)); auto block_num_ptr = block_num_t.data_ptr(); block_num_ptr[local_rank] = config_.block_num; execAllGather({{block_num_t}, ParallelMode::DP_AND_TP}); diff --git a/rtp_llm/cpp/cache/MemoryEvaluationHelper.cc b/rtp_llm/cpp/cache/MemoryEvaluationHelper.cc index f2813ffeda..7f86abd1a5 100644 --- a/rtp_llm/cpp/cache/MemoryEvaluationHelper.cc +++ b/rtp_llm/cpp/cache/MemoryEvaluationHelper.cc @@ -7,6 +7,9 @@ #elif USING_ROCM #include #include "rtp_llm/models_py/bindings/rocm/hip_host_utils.h" +#elif USING_XPU +#include +#include #endif #include "rtp_llm/models_py/bindings/core/ExecOps.h" @@ -59,6 +62,22 @@ size_t MemoryEvaluationHelper::getDefaultRuntimeMemorySize(const RuntimeConfig& check_cuda_value(cudaMemGetInfo(&free_gpu_bytes, &total_gpu_bytes)); #elif USING_ROCM ROCM_CHECK(hipMemGetInfo(&free_gpu_bytes, &total_gpu_bytes)); +#elif USING_XPU + { + auto device_idx = static_cast(c10::xpu::current_device()); + auto* props = at::xpu::getDeviceProperties(device_idx); + RTP_LLM_CHECK_WITH_INFO(props != nullptr, + "at::xpu::getDeviceProperties returned null for device " + + std::to_string(device_idx)); + total_gpu_bytes = props->global_mem_size; + auto stats = c10::xpu::XPUCachingAllocator::getDeviceStats(device_idx); + // Match getGpuExecStatus(): use reserved_bytes (memory the caching allocator + // holds from the driver), not allocated_bytes (the live subset), so the two + // memory accounting paths stay consistent. + size_t reserved = + stats.reserved_bytes[static_cast(c10::CachingAllocator::StatType::AGGREGATE)].current; + free_gpu_bytes = (total_gpu_bytes > reserved) ? (total_gpu_bytes - reserved) : 0; + } #endif const auto minimal_runtime_bytes = std::max(2048L * 1024 * 1024, (long)(total_gpu_bytes * 0.05)); if (reserve_runtime_mem_bytes < minimal_runtime_bytes) { diff --git a/rtp_llm/cpp/cache/MemoryLayoutStrategy.cc b/rtp_llm/cpp/cache/MemoryLayoutStrategy.cc index 91e555a0e7..056572c21e 100644 --- a/rtp_llm/cpp/cache/MemoryLayoutStrategy.cc +++ b/rtp_llm/cpp/cache/MemoryLayoutStrategy.cc @@ -282,7 +282,7 @@ std::vector MemoryLayoutStrategy::createPartitionedSubBlocks(const to BlockInfo MemoryLayoutStrategy::makeBlockInfo(const torch::Tensor& tensor, void* addr, size_t size_bytes) const { auto dev = tensor.device(); BlockInfo info; - info.is_cuda = dev.is_cuda(); + info.is_cuda = dev.is_cuda() || dev.is_xpu(); info.device_index = dev.index(); info.scalar_type = static_cast(tensor.scalar_type()); info.addr = addr; diff --git a/rtp_llm/cpp/cache/connector/memory/KVCacheMemoryConnector.cc b/rtp_llm/cpp/cache/connector/memory/KVCacheMemoryConnector.cc index 3f1b7109d2..23b943c032 100644 --- a/rtp_llm/cpp/cache/connector/memory/KVCacheMemoryConnector.cc +++ b/rtp_llm/cpp/cache/connector/memory/KVCacheMemoryConnector.cc @@ -640,8 +640,8 @@ bool KVCacheMemoryConnector::appendCopyBytesToBuffers(const BlockInfo& return false; } - auto mem_device = mem_block.is_cuda ? torch::kCUDA : torch::kCPU; - auto gpu_device = gpu_block.is_cuda ? torch::kCUDA : torch::kCPU; + auto mem_device = mem_block.is_cuda ? getTorchDevice() : torch::kCPU; + auto gpu_device = gpu_block.is_cuda ? getTorchDevice() : torch::kCPU; auto mem_tensor = torch::from_blob(static_cast(static_cast(mem_block.addr) + byte_off), {(int64_t)gpu_block.size_bytes}, torch::TensorOptions().dtype(torch::kUInt8).device(mem_device)); diff --git a/rtp_llm/cpp/cache/connector/p2p/LayerBlockConverterImpl.h b/rtp_llm/cpp/cache/connector/p2p/LayerBlockConverterImpl.h index 360bf1c0bd..f0e7fc9c51 100644 --- a/rtp_llm/cpp/cache/connector/p2p/LayerBlockConverterImpl.h +++ b/rtp_llm/cpp/cache/connector/p2p/LayerBlockConverterImpl.h @@ -33,8 +33,8 @@ class LayerBlockConverterImpl: public LayerBlockConverter { return; } BlockInfo info; - info.is_cuda = t.is_cuda(); - info.device_index = t.is_cuda() ? static_cast(t.get_device()) : 0; + info.is_cuda = t.is_cuda() || t.is_xpu(); + info.device_index = (t.is_cuda() || t.is_xpu()) ? static_cast(t.get_device()) : 0; info.scalar_type = static_cast(t.scalar_type()); info.addr = t.data_ptr(); info.size_bytes = static_cast(t.nbytes()); diff --git a/rtp_llm/cpp/cache/connector/p2p/transfer/tcp/CudaCopyUtil.cc b/rtp_llm/cpp/cache/connector/p2p/transfer/tcp/CudaCopyUtil.cc index efd45e8e2c..30f9bb0d78 100644 --- a/rtp_llm/cpp/cache/connector/p2p/transfer/tcp/CudaCopyUtil.cc +++ b/rtp_llm/cpp/cache/connector/p2p/transfer/tcp/CudaCopyUtil.cc @@ -1,4 +1,5 @@ #include "rtp_llm/cpp/cache/connector/p2p/transfer/tcp/CudaCopyUtil.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/models_py/bindings/NoBlockCopy.h" #include "rtp_llm/cpp/utils/Logger.h" #include @@ -26,7 +27,7 @@ bool CudaCopyUtil::batchCopyToHost(std::vector& tasks) { RTP_LLM_LOG_WARNING("dst_ptr is nullptr, caller must pre-allocate dst_ptr"); return false; } - params.multi_src.push_back(wrapRawPtr(task.src_ptr, task.size, torch::kCUDA)); + params.multi_src.push_back(wrapRawPtr(task.src_ptr, task.size, getTorchDevice())); params.multi_dst.push_back(wrapRawPtr(task.dst_ptr, task.size, torch::kCPU)); } @@ -49,7 +50,7 @@ bool CudaCopyUtil::batchCopyToDevice(std::vector& tasks) { return false; } params.multi_src.push_back(wrapRawPtr(task.src_ptr, task.size, torch::kCPU)); - params.multi_dst.push_back(wrapRawPtr(task.dst_ptr, task.size, torch::kCUDA)); + params.multi_dst.push_back(wrapRawPtr(task.dst_ptr, task.size, getTorchDevice())); } execNoBlockCopy(params); diff --git a/rtp_llm/cpp/engine_base/TorchProfiler.h b/rtp_llm/cpp/engine_base/TorchProfiler.h index ac4d70f5ff..05fb5b6c5e 100644 --- a/rtp_llm/cpp/engine_base/TorchProfiler.h +++ b/rtp_llm/cpp/engine_base/TorchProfiler.h @@ -38,7 +38,11 @@ class TorchProfile { std::string output_dir_; static std::atomic count_; tpi::ProfilerConfig config_ = tpi::ProfilerConfig(tpi::ProfilerState::KINETO, /*report_input_shapes=*/true); +#if USING_XPU + std::set activities_{tpi::ActivityType::CPU, tpi::ActivityType::XPU}; +#else std::set activities_{tpi::ActivityType::CPU, tpi::ActivityType::CUDA}; +#endif bool stopped_ = true; }; diff --git a/rtp_llm/cpp/engine_base/WeightsConverter.cc b/rtp_llm/cpp/engine_base/WeightsConverter.cc index 17cd1a0f04..67e3a9d25e 100644 --- a/rtp_llm/cpp/engine_base/WeightsConverter.cc +++ b/rtp_llm/cpp/engine_base/WeightsConverter.cc @@ -1,5 +1,6 @@ #include "rtp_llm/cpp/engine_base/WeightsConverter.h" #include "rtp_llm/cpp/pybind/PyUtils.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/cpp/models/models_weight/W.h" #include using namespace std; @@ -11,7 +12,7 @@ WeightsConverter::WeightsConverter(bool need_copy, rtp_llm::QuantAlgo quant_alog torch::Tensor WeightsConverter::CopyTensorToGPU(const torch::Tensor& tensor) { if (need_copy_) { - auto gpu_tensor = torch::empty_like(tensor, torch::TensorOptions().device(torch::kCUDA)); + auto gpu_tensor = torch::empty_like(tensor, torch::TensorOptions().device(getTorchDevice())); gpu_tensor.copy_(tensor, /*non_blocking=*/true); return gpu_tensor; } else { diff --git a/rtp_llm/cpp/engine_base/stream/GenerateStream.cc b/rtp_llm/cpp/engine_base/stream/GenerateStream.cc index 8b7e0d9f65..3b8e9a2928 100644 --- a/rtp_llm/cpp/engine_base/stream/GenerateStream.cc +++ b/rtp_llm/cpp/engine_base/stream/GenerateStream.cc @@ -2,8 +2,10 @@ #include #include #include -#if defined(USING_CUDA) || defined(USING_ROCM) +#if USING_CUDA || USING_ROCM #include +#elif USING_XPU +#include #endif #include "autil/EnvUtil.h" #include "rtp_llm/cpp/engine_base/stream/GenerateStream.h" @@ -90,8 +92,10 @@ GenerateStream::GenerateStream(const shared_ptr& input, generate_input_, init_batch_size, maxBatchSize(), special_tokens_.eos_token_id); if (generateConfig()->random_seed.has_value()) { -#if defined(USING_CUDA) || defined(USING_ROCM) +#if USING_CUDA || USING_ROCM generator_ = torch::make_generator(); +#elif USING_XPU + generator_ = torch::make_generator(); #else generator_ = torch::make_generator(); #endif @@ -888,7 +892,7 @@ void GenerateStream::updateLogitProcessorStatus(const StreamUpdateInfo& update_i void GenerateStream::setLoss(const torch::Tensor& loss) { RTP_LLM_PROFILE_FUNCTION(); - auto loss_cpu = loss.is_cuda() ? loss.cpu() : loss; + auto loss_cpu = (loss.is_cuda() || loss.is_xpu()) ? loss.cpu() : loss; auto loss_size = loss_cpu.numel(); RTP_LLM_CHECK(loss_index_ + loss_size < inputLength()); memcpy(loss_.data_ptr() + loss_index_, loss_cpu.data_ptr(), loss_size * sizeof(float)); @@ -897,7 +901,7 @@ void GenerateStream::setLoss(const torch::Tensor& loss) { void GenerateStream::setSoftmaxProbs(const torch::Tensor& softmax_probs, int start_pos) { RTP_LLM_PROFILE_FUNCTION(); - auto probs_cpu = softmax_probs.is_cuda() ? softmax_probs.cpu() : softmax_probs; + auto probs_cpu = (softmax_probs.is_cuda() || softmax_probs.is_xpu()) ? softmax_probs.cpu() : softmax_probs; RTP_LLM_CHECK(probs_cpu.dim() == 2); RTP_LLM_CHECK(probs_cpu.size(0) == currentBatchSize()); auto num_probs = probs_cpu.size(1); diff --git a/rtp_llm/cpp/models/BUILD b/rtp_llm/cpp/models/BUILD index c3afc82afd..687b2a77a3 100644 --- a/rtp_llm/cpp/models/BUILD +++ b/rtp_llm/cpp/models/BUILD @@ -130,12 +130,27 @@ cc_library( "//rtp_llm/models_py/bindings/core:cache_store_async_writer", "//rtp_llm/cpp/utils:debug_utils", "//rtp_llm/cpp/utils:profiling_scope", - "//rtp_llm/cpp/cuda_graph:cuda_graph_impl", - "//rtp_llm/cpp/cuda_graph:cuda_graph_base", - "//rtp_llm/cpp/cuda_graph:cuda_graph_hdrs_lib", - "//rtp_llm/models_py/bindings/common:fuse_copy_op", - "//rtp_llm/cpp/multimodal_processor:multimodal_types", - ], + ] + select({ + "//:using_cuda": [ + "//rtp_llm/cpp/cuda_graph:cuda_graph_impl", + "//rtp_llm/cpp/cuda_graph:cuda_graph_base", + "//rtp_llm/cpp/cuda_graph:cuda_graph_hdrs_lib", + "//rtp_llm/models_py/bindings/common:fuse_copy_op", + "//rtp_llm/cpp/multimodal_processor:multimodal_types", + ], + "//:using_rocm": [ + "//rtp_llm/cpp/cuda_graph:cuda_graph_impl", + "//rtp_llm/cpp/cuda_graph:cuda_graph_base", + "//rtp_llm/cpp/cuda_graph:cuda_graph_hdrs_lib", + "//rtp_llm/models_py/bindings/common:fuse_copy_op", + "//rtp_llm/cpp/multimodal_processor:multimodal_types", + ], + "//:using_xpu": [ + "//rtp_llm/cpp/cuda_graph:cuda_graph_base", + "//rtp_llm/models_py/bindings/common:fuse_copy_op", + ], + "//conditions:default": [], + }), visibility = ["//visibility:public"], ) diff --git a/rtp_llm/cpp/models/ModelTypes.cc b/rtp_llm/cpp/models/ModelTypes.cc index 884f121439..ea3797bd34 100644 --- a/rtp_llm/cpp/models/ModelTypes.cc +++ b/rtp_llm/cpp/models/ModelTypes.cc @@ -4,12 +4,13 @@ namespace rtp_llm { + void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallelism_config) { if (parallelism_config.tp_size <= 1) { return; } const size_t shape_hints_size = GptModelInputIndex::gptModelInputLength; - auto shape_hints_t = torch::empty({(int64_t)shape_hints_size}, torch::kInt32).pin_memory(); + auto shape_hints_t = maybePinMemory(torch::empty({(int64_t)shape_hints_size}, torch::kInt32)); auto shape_hints_ptr = shape_hints_t.data_ptr(); shape_hints_ptr[GptModelInputIndex::comboTokens] = inputs.combo_tokens.defined() ? inputs.combo_tokens.numel() : 0; shape_hints_ptr[GptModelInputIndex::inputLengths] = @@ -83,7 +84,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel } const size_t mm_features_num = shape_hints_ptr[GptModelInputIndex::mmFeaturesNum]; if (mm_features_num) { - mm_features_shape_t = torch::empty({(int64_t)mm_features_num}, torch::kInt32).pin_memory(); + mm_features_shape_t = maybePinMemory(torch::empty({(int64_t)mm_features_num}, torch::kInt32)); mm_features_shape_ptr = mm_features_shape_t.data_ptr(); for (size_t i = 0; i < mm_features_num; ++i) { mm_features_shape_ptr[i] = @@ -98,7 +99,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel // so we send its element count first ("先传shape") and allocate a 1-D buffer on non-root. const size_t mm_extra_input_num = (size_t)shape_hints_ptr[GptModelInputIndex::mmHasExtraInput]; if (mm_extra_input_num) { - mm_extra_input_shape_t = torch::empty({(int64_t)mm_extra_input_num}, torch::kInt64).pin_memory(); + mm_extra_input_shape_t = maybePinMemory(torch::empty({(int64_t)mm_extra_input_num}, torch::kInt64)); mm_extra_input_shape_ptr = mm_extra_input_shape_t.data_ptr(); for (size_t i = 0; i < mm_extra_input_num; ++i) { mm_extra_input_shape_ptr[i] = @@ -126,13 +127,13 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel auto torch_dtype = dataTypeToTorchType(dtype); auto options = torch::TensorOptions(torch_dtype); if (atype == rtp_llm::AllocationType::DEVICE) { - options = options.device(torch::kCUDA); + options = options.device(getTorchDevice()); } std::vector dims64(dims.begin(), dims.end()); auto tensor = torch::empty(dims64, options); // NCCL broadcast requires pinned memory for CPU buffers if (atype != rtp_llm::AllocationType::DEVICE) { - tensor = tensor.pin_memory(); + tensor = maybePinMemory(tensor); } return tensor; }; @@ -200,7 +201,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel for (auto mm_index = 0; mm_index < mm_features_num; ++mm_index) { mm_features.emplace_back(torch::empty({(int64_t)mm_features_shape_ptr[mm_index], (int64_t)shape_hints_ptr[GptModelInputIndex::mmFeaturesSize]}, - torch::TensorOptions().dtype(mm_dtype).device(torch::kCUDA))); + torch::TensorOptions().dtype(mm_dtype).device(getTorchDevice()))); } inputs.multimodal_features = std::move(mm_features); } @@ -211,7 +212,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel for (size_t i = 0; i < mm_extra_input_num; ++i) { mm_extra_input.emplace_back( torch::empty({(int64_t)mm_extra_input_shape_ptr[i]}, - torch::TensorOptions().dtype(extra_dtype).device(torch::kCUDA))); + torch::TensorOptions().dtype(extra_dtype).device(getTorchDevice()))); } inputs.mm_extra_input = std::move(mm_extra_input); } @@ -289,7 +290,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel for (auto* tp : tensor_ptrs) { auto nb = static_cast(tp->nbytes()); - if (tp->is_cuda()) { + if (tp->is_cuda() || tp->is_xpu()) { gpu_entries.push_back({tp, gpu_total_bytes, nb}); gpu_total_bytes += align_up(nb, kPackAlignment); } else { @@ -305,7 +306,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel torch::Tensor cpu_packed, gpu_packed; if (cpu_total_bytes > 0) { - cpu_packed = torch::empty({cpu_total_bytes}, torch::kUInt8).pin_memory(); + cpu_packed = maybePinMemory(torch::empty({cpu_total_bytes}, torch::kUInt8)); if (is_root) { auto* base = static_cast(cpu_packed.data_ptr()); for (auto& e : cpu_entries) { @@ -316,7 +317,7 @@ void tpSyncModelInputs(GptModelInputs& inputs, const ParallelismConfig& parallel } if (gpu_total_bytes > 0) { - gpu_packed = torch::empty({gpu_total_bytes}, torch::TensorOptions(torch::kUInt8).device(torch::kCUDA)); + gpu_packed = torch::empty({gpu_total_bytes}, torch::TensorOptions(torch::kUInt8).device(getTorchDevice())); if (is_root) { for (auto& e : gpu_entries) { auto contig = e.tensor->contiguous(); diff --git a/rtp_llm/cpp/models/PyWrappedModel.cc b/rtp_llm/cpp/models/PyWrappedModel.cc index a6bb94f83b..cbc00b9a81 100644 --- a/rtp_llm/cpp/models/PyWrappedModel.cc +++ b/rtp_llm/cpp/models/PyWrappedModel.cc @@ -25,23 +25,27 @@ using namespace std; namespace rtp_llm { torch::Tensor PyWrappedModel::tensorHoldHostAndToCuda(const torch::Tensor& tensor) { - if (tensor.device().is_cuda()) { + if ((tensor.device().is_cuda() || tensor.device().is_xpu())) { return tensor; } buffer_holder_.hold_host(tensor); if (tensor.numel() == 0) { - return torch::empty(tensor.sizes(), torch::TensorOptions(tensor.dtype()).device(torch::kCUDA)); + return torch::empty(tensor.sizes(), torch::TensorOptions(tensor.dtype()).device(getTorchDevice())); } // NOTE: since is_pinned() operation costs a lot cpu time, we only check it when pinned_check_remaining_ > 0. + // XPU does not support pinned memory; fusedCopy uses SYCL queue.memcpy which + // works with any host allocation, so skip the pinned check entirely. +#if !USING_XPU if (pinned_check_remaining_ > 0) { RTP_LLM_CHECK_WITH_INFO(tensor.is_pinned(), "tensor is not pinned, fused copy requires pinned memory"); } +#endif // create tensor on cuda - auto cuda_tensor = torch::empty(tensor.sizes(), torch::TensorOptions(tensor.dtype()).device(torch::kCUDA)); + auto cuda_tensor = torch::empty(tensor.sizes(), torch::TensorOptions(tensor.dtype()).device(getTorchDevice())); d2d_copies_.add(tensor.data_ptr(), cuda_tensor.data_ptr(), tensor.nbytes()); @@ -83,11 +87,21 @@ torch_ext::PyAttentionInputs PyWrappedModel::buildPyAttentionInputs(const GptMod py_attn_inputs.sequence_lengths = inputs.sequence_lengths; py_attn_inputs.input_lengths = inputs.input_lengths; + // Pinned (page-locked) host memory speeds up H2D copies on CUDA/ROCm, but + // XPU does not support it. Resolve once via preprocessor for all sites below. +#if USING_XPU + constexpr bool kPinHostMem = false; +#else + constexpr bool kPinHostMem = true; +#endif + if (inputs.kv_cache_kernel_block_id.defined()) { - py_attn_inputs.kv_cache_kernel_block_id = inputs.kv_cache_kernel_block_id.clone().pin_memory(); + auto t = inputs.kv_cache_kernel_block_id.clone(); + py_attn_inputs.kv_cache_kernel_block_id = kPinHostMem ? t.pin_memory() : t; } if (inputs.kv_cache_block_id.defined()) { - py_attn_inputs.kv_cache_block_id = inputs.kv_cache_block_id.clone().pin_memory(); + auto t = inputs.kv_cache_block_id.clone(); + py_attn_inputs.kv_cache_block_id = kPinHostMem ? t.pin_memory() : t; } if (inputs.kv_cache_layer_to_group.defined()) { py_attn_inputs.kv_cache_layer_to_group = inputs.kv_cache_layer_to_group; @@ -128,9 +142,9 @@ torch_ext::PyAttentionInputs PyWrappedModel::buildPyAttentionInputs(const GptMod if (context_batch_size > 0) { torch::Tensor cu_seqlens = - torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(true)); + torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(kPinHostMem)); torch::Tensor cu_kv_seqlens = - torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(true)); + torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(kPinHostMem)); cu_seqlens.slice(0, 1, context_batch_size + 1) = py_attn_inputs.input_lengths.cumsum(0); cu_kv_seqlens.slice(0, 1, context_batch_size + 1) = @@ -144,16 +158,16 @@ torch_ext::PyAttentionInputs PyWrappedModel::buildPyAttentionInputs(const GptMod } else { py_attn_inputs.total_tokens = 0; py_attn_inputs.cu_seqlens = - torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(true)); + torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(kPinHostMem)); py_attn_inputs.cu_seqlens_device = - torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); py_attn_inputs.cu_kv_seqlens_device = - torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + torch::zeros({batch_size + 1}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); torch::Tensor decode_cu_seqlens = torch::arange(0, py_attn_inputs.sequence_lengths.size(0) + 1, 1, - torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(true)); + torch::TensorOptions(torch::kInt32).device(torch::kCPU).pinned_memory(kPinHostMem)); py_attn_inputs.decode_cu_seqlens = decode_cu_seqlens; py_attn_inputs.decode_cu_seqlens_device = tensorHoldHostAndToCuda(decode_cu_seqlens); } @@ -163,11 +177,11 @@ torch_ext::PyAttentionInputs PyWrappedModel::buildPyAttentionInputs(const GptMod py_attn_inputs.input_lengths_device = tensorHoldHostAndToCuda(py_attn_inputs.input_lengths); // In qwen3-next target verify mode, sequence_lengths_plus_1_device uses prefix_lengths - if (py_attn_inputs.is_target_verify) { - auto sequence_lengths_plus_1 = (py_attn_inputs.prefix_lengths + 1).pin_memory(); - py_attn_inputs.sequence_lengths_plus_1_device = tensorHoldHostAndToCuda(sequence_lengths_plus_1); - } else { - auto sequence_lengths_plus_1 = (py_attn_inputs.sequence_lengths + 1).pin_memory(); + { + const auto& base = py_attn_inputs.is_target_verify + ? py_attn_inputs.prefix_lengths + : py_attn_inputs.sequence_lengths; + auto sequence_lengths_plus_1 = kPinHostMem ? (base + 1).pin_memory() : (base + 1); py_attn_inputs.sequence_lengths_plus_1_device = tensorHoldHostAndToCuda(sequence_lengths_plus_1); } @@ -213,14 +227,14 @@ torch_ext::BertEmbeddingInputs PyWrappedModel::buildBertEmbeddingInputs(const Gp // Convert combo_position_ids from Buffer to torch::Tensor if (inputs.combo_position_ids.defined()) { - bert_embedding_inputs.combo_position_ids = inputs.combo_position_ids.cuda(); + bert_embedding_inputs.combo_position_ids = inputs.combo_position_ids.to(getTorchDevice()); } // Convert combo_tokens_type_ids from Buffer to torch::Tensor if (inputs.combo_tokens_type_ids.defined()) { { DevicePerfWrapper wrapper(enable_device_perf_, "py model combo_tokens.cuda()"); - bert_embedding_inputs.combo_tokens_type_ids = inputs.combo_tokens_type_ids.cuda(); + bert_embedding_inputs.combo_tokens_type_ids = inputs.combo_tokens_type_ids.to(getTorchDevice()); } } @@ -346,7 +360,7 @@ GptModelOutputs PyWrappedModel::forwardMicroBatched(const GptModelInputs& inputs calculatePaddingOffset(py_attn_inputs); py_attn_inputs.padding_offset = tensorHoldHostAndToCuda(py_attn_inputs.padding_offset); - torch::Tensor token_ids = micro_inputs.combo_tokens.clone().cuda(); + torch::Tensor token_ids = micro_inputs.combo_tokens.clone().to(getTorchDevice()); torch::Tensor input_hiddens = inputs.last_hidden_states.defined() ? inputs.last_hidden_states : torch::empty({0}); input_list.emplace_back(PyModelInputs{token_ids, @@ -394,7 +408,7 @@ GptModelOutputs PyWrappedModel::forwardMicroBatched(const GptModelInputs& inputs size_t hidden_size = description_.attention_conf.head_num * description_.attention_conf.size_per_head; hidden_states = torch::empty({(int64_t)total_tokens, (int64_t)hidden_size}, - torch::TensorOptions(dataTypeToTorchType(description_.data_type)).device(torch::kCUDA)); + torch::TensorOptions(dataTypeToTorchType(description_.data_type)).device(getTorchDevice())); int offset = 0; for (int i = 0; i < py_model_outputs.size(); i++) { RTP_LLM_CHECK_WITH_INFO( @@ -421,10 +435,10 @@ torch_ext::PyEmbeddingInputs PyWrappedModel::buildPyEmbeddingInputs(const GptMod DevicePerfWrapper wrapper(enable_device_perf_, "py model buildPyEmbeddingInputs"); torch_ext::PyEmbeddingInputs embedding_inputs; if (inputs.combo_tokens_type_ids.defined()) { - embedding_inputs.combo_tokens_type_ids = inputs.combo_tokens_type_ids.cuda(); + embedding_inputs.combo_tokens_type_ids = inputs.combo_tokens_type_ids.to(getTorchDevice()); } if (inputs.text_tokens_mask.defined()) { - embedding_inputs.text_tokens_mask = inputs.text_tokens_mask.cuda(); + embedding_inputs.text_tokens_mask = inputs.text_tokens_mask.to(getTorchDevice()); } return embedding_inputs; } @@ -435,19 +449,19 @@ torch_ext::PyMultimodalInputs PyWrappedModel::buildPyMultimodalInputs(const GptM if (inputs.multimodal_features && !inputs.multimodal_features.value().empty()) { std::vector multimodal_features; for (const auto& feature : inputs.multimodal_features.value()) { - multimodal_features.emplace_back(feature.cuda()); + multimodal_features.emplace_back(feature.to(getTorchDevice())); } multimodal_input.multimodal_features = multimodal_features; } if (inputs.mm_extra_input && !inputs.mm_extra_input.value().empty()) { std::vector mm_extra_input; for (const auto& embed : inputs.mm_extra_input.value()) { - mm_extra_input.emplace_back(embed.cuda()); + mm_extra_input.emplace_back(embed.to(getTorchDevice())); } multimodal_input.mm_extra_input = mm_extra_input; } if (inputs.mm_features_locs.defined()) { - multimodal_input.mm_features_locs = inputs.mm_features_locs.cuda(); + multimodal_input.mm_features_locs = inputs.mm_features_locs.to(getTorchDevice()); } return multimodal_input; } @@ -467,7 +481,7 @@ GptModelOutputs PyWrappedModel::forward(const GptModelInputs& inputs) { return forwardMicroBatched(inputs); } PyContextParallelParams cp_params; - if (device_props_.enable_prefill_cp) { + if (effective_enable_prefill_cp_) { context_parallel_processor_->handleInputs(const_cast(inputs), cp_params); } @@ -485,7 +499,7 @@ GptModelOutputs PyWrappedModel::forward(const GptModelInputs& inputs) { auto multimodal_inputs = buildPyMultimodalInputs(inputs); auto attention_inputs = buildPyAttentionInputs(inputs); auto bert_embedding_inputs = buildBertEmbeddingInputs(inputs); - if (device_props_.enable_prefill_cp) { + if (effective_enable_prefill_cp_) { attention_inputs.context_parallel_info = cp_params; } @@ -545,7 +559,7 @@ GptModelOutputs PyWrappedModel::forward(const GptModelInputs& inputs) { } RTP_LLM_LOG_DEBUG("Python object instance forward method called successfully."); - if (device_props_.enable_prefill_cp) { + if (effective_enable_prefill_cp_) { size_t num_valid_tokens = context_parallel_processor_->handleOutputs(hidden_states, inputs, cp_params); return callForwardPostLayers(hidden_states, inputs, true, num_valid_tokens); } @@ -669,7 +683,7 @@ GptModelOutputs PyWrappedModel::forwardPostLayers(torch::Tensor hidden, printTorchTensorData(lm_output_indexes, "lm_output_indexes"); buffer_holder_.hold_host(lm_output_indexes); - auto lm_output_indexes_device = lm_output_indexes.to(torch::kCUDA, /*non_blocking=*/true); + auto lm_output_indexes_device = lm_output_indexes.to(getTorchDevice(), /*non_blocking=*/true); torch::Tensor last_hidden; if (has_context_request && !need_all_logits) { diff --git a/rtp_llm/cpp/models/PyWrappedModel.h b/rtp_llm/cpp/models/PyWrappedModel.h index 06c62a0c7e..2f9dc1f49d 100644 --- a/rtp_llm/cpp/models/PyWrappedModel.h +++ b/rtp_llm/cpp/models/PyWrappedModel.h @@ -21,6 +21,9 @@ #include "rtp_llm/models_py/bindings/core/DeviceData.h" #include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/models_py/bindings/core/CacheStoreAsyncWriter.h" +#if USING_XPU +#include +#endif namespace py = pybind11; @@ -95,6 +98,7 @@ class PyWrappedModel: public ModelBase { bool check_nan_{false}; std::unique_ptr context_parallel_processor_{nullptr}; + bool effective_enable_prefill_cp_{false}; std::unique_ptr cache_store_async_writer_; // Accumulated H2D copies from tensorHoldHostAndToCuda(); flushed as one kernel per forward. @@ -128,9 +132,11 @@ inline PyWrappedModel::PyWrappedModel(const GptModelInitParams& params, model_id_ = params.model_id; kv_cache_layer_layout_ = params.kv_cache_layer_layout; if (abs(description_.residual_scalar - 1.0) > 1e-6) { - auto residual_tensor = torch::tensor({(float)description_.residual_scalar}, torch::kFloat32).cuda(); + auto residual_tensor = torch::tensor({(float)description_.residual_scalar}, torch::kFloat32).to(getTorchDevice()); #if USING_CUDA c10::cuda::getCurrentCUDAStream().synchronize(); +#elif USING_XPU + c10::xpu::getCurrentXPUStream().synchronize(); #endif residual_scale_fp32_ = residual_tensor; residual_scale_ = residual_tensor.to(dataTypeToTorchType(description_.data_type)); @@ -251,9 +257,16 @@ inline PyWrappedModel::PyWrappedModel(const GptModelInitParams& params, static_cast(params.parallelism_config.tp_size), static_cast(params.parallelism_config.tp_rank)); } +#elif USING_XPU + // XPU: no CUDA graph support; just synchronize the device + c10::impl::VirtualGuardImpl impl(c10::DeviceType::XPU); + impl.synchronizeStream(impl.getStream(c10::Device(c10::DeviceType::XPU, static_cast(getDeviceId())))); + enable_cuda_graph_ = false; #else - RTP_LLM_CHECK_WITH_INFO(false, "CUDA/HIP Graph is only supported on CUDA/ROCm platform"); + RTP_LLM_LOG_WARNING("CUDA/HIP Graph is not supported on this platform, skipping"); + enable_cuda_graph_ = false; #endif +#if USING_CUDA || USING_ROCM if (weights_.position_encoding) { graph_runner_->setPositionEncoding(weights_.position_encoding->kernel.cuda()); } @@ -265,6 +278,7 @@ inline PyWrappedModel::PyWrappedModel(const GptModelInitParams& params, auto py_initialize_method = py_instance.attr("initialize"); py_init_result = py_initialize_method(init_resources); graph_runner_->initCapture(); +#endif } auto py_init_success = py_init_result.cast(); @@ -274,11 +288,18 @@ inline PyWrappedModel::PyWrappedModel(const GptModelInitParams& params, cache_store_async_writer_ = std::make_unique(); +#if USING_CUDA || USING_ROCM if (device_props_.enable_prefill_cp) { context_parallel_processor_ = ContextParallelProcessorFactory::create(ProcessorType::ZIG_ZAG, params.parallelism_config); + effective_enable_prefill_cp_ = true; RTP_LLM_LOG_INFO("Context parallel processor initialized with ZIG_ZAG strategy."); } +#elif USING_XPU + if (device_props_.enable_prefill_cp) { + RTP_LLM_LOG_WARNING("Prefill context parallelism is not supported on XPU, ignoring enable_prefill_cp"); + } +#endif RTP_LLM_LOG_INFO("PyWrappedModel initialized done."); } diff --git a/rtp_llm/cpp/models/Sampler.cc b/rtp_llm/cpp/models/Sampler.cc index 090ea57798..cff0425489 100644 --- a/rtp_llm/cpp/models/Sampler.cc +++ b/rtp_llm/cpp/models/Sampler.cc @@ -40,17 +40,17 @@ SamplerOutput Sampler::forward(const SamplerInputs& inputs) { // Keep success on CUDA to avoid a blocking D2H copy: the GPU sampling kernel writes success // directly, and callers that need CPU access should call .cpu() explicitly. auto all_success = - torch::empty({(int64_t)inputs.batch_size}, torch::TensorOptions().dtype(torch::kBool).device(torch::kCUDA)); + torch::empty({(int64_t)inputs.batch_size}, torch::TensorOptions().dtype(torch::kBool).device(getTorchDevice())); auto all_beam_indices = has_num_beams ? torch::empty({(int64_t)inputs.batch_size_out}, torch::kInt32) : torch::Tensor(); // Move token_ids to CUDA once so sampleGreedy writes GPU→GPU (no blocking D2H sync). // Callers that need CPU access should call .cpu() explicitly. // Use blocking transfer: on ROCm, hipMemcpyAsync from pageable memory is truly async // and can cause memory access faults if a kernel reads the buffer before transfer completes. - auto inputs_token_ids_cuda = inputs.token_ids.to(torch::kCUDA); + auto inputs_token_ids_cuda = inputs.token_ids.to(getTorchDevice()); auto all_token_ids_out = variable_num_beams ? torch::empty({(int64_t)inputs.batch_size_out, (int64_t)max_seq_len}, - torch::TensorOptions().dtype(torch::kInt32).device(torch::kCUDA)) : + torch::TensorOptions().dtype(torch::kInt32).device(getTorchDevice())) : inputs_token_ids_cuda; auto all_cum_log_probs_out = variable_num_beams && inputs.cum_log_probs.defined() ? torch::empty({(int64_t)inputs.batch_size_out}, torch::kFloat32) : @@ -138,6 +138,15 @@ SamplerOutput Sampler::forward(const SamplerInputs& inputs) { } } else { success.fill_(true); +#if USING_XPU + // XPU's greedy sampler returns an undefined `success` tensor but + // still writes valid ids into token_ids_in (params.token_ids). + // Mirror the success-defined branch so variable-beam batches are + // populated. Guarded so CUDA/ROCm behavior stays byte-identical. + if (variable_num_beams) { + token_ids_out.copy_(token_ids_in); + } +#endif } } else { RTP_LLM_LOG_DEBUG("current_num_beams_in is %d", cur_num_beams_in); @@ -164,11 +173,11 @@ SamplerOutput Sampler::forward(const SamplerInputs& inputs) { cum_log_probs_in.reshape({(int64_t)beam_batch_size, (int64_t)cur_num_beams_in}) : torch::zeros({(int64_t)beam_batch_size, (int64_t)cur_num_beams_in}); - auto logits_t = logits_reshaped.to(torch::kCUDA); - auto token_ids_in_t = token_ids_in_reshaped.to(torch::kCUDA); - auto input_lengths_t = input_lengths_reshaped.to(torch::kCUDA); - auto sequence_lengths_t = sequence_lengths_reshaped.to(torch::kCUDA); - auto cum_log_probs_in_t = cum_log_probs_in_reshaped.to(torch::kCUDA); + auto logits_t = logits_reshaped.to(getTorchDevice()); + auto token_ids_in_t = token_ids_in_reshaped.to(getTorchDevice()); + auto input_lengths_t = input_lengths_reshaped.to(getTorchDevice()); + auto sequence_lengths_t = sequence_lengths_reshaped.to(getTorchDevice()); + auto cum_log_probs_in_t = cum_log_probs_in_reshaped.to(getTorchDevice()); auto output = execSampleBeamSearch({logits_t, token_ids_in_t, diff --git a/rtp_llm/cpp/models/eplb/ExpertBalancer.cc b/rtp_llm/cpp/models/eplb/ExpertBalancer.cc index 09fcf2cba3..3184351cd6 100644 --- a/rtp_llm/cpp/models/eplb/ExpertBalancer.cc +++ b/rtp_llm/cpp/models/eplb/ExpertBalancer.cc @@ -7,6 +7,7 @@ using namespace std; + namespace rtp_llm { void EplbPlanBuffers::init(size_t log_exp_num, @@ -16,14 +17,14 @@ void EplbPlanBuffers::init(size_t log_exp_num, size_t ep_size, DataType dtype, QuantAlgo quant_algo) { - auto gpu_i32 = torch::TensorOptions(torch::kInt32).device(torch::kCUDA); + auto gpu_i32 = torch::TensorOptions(torch::kInt32).device(getTorchDevice()); auto cpu_i32 = torch::kInt32; layer_id_buf = torch::zeros({1}, gpu_i32); logic_expert_cnt = torch::zeros({(int64_t)log_exp_num}, gpu_i32); - logic_expert_cnt_host = torch::zeros({(int64_t)log_exp_num}, cpu_i32).pin_memory(); + logic_expert_cnt_host = maybePinMemory(torch::zeros({(int64_t)log_exp_num}, cpu_i32)); log2phy = torch::zeros({(int64_t)log_exp_num, (int64_t)(phy_exp_num - log_exp_num + 1)}, gpu_i32); - log2phy_host = torch::zeros({(int64_t)log_exp_num, (int64_t)(phy_exp_num - log_exp_num + 1)}, cpu_i32).pin_memory(); + log2phy_host = maybePinMemory(torch::zeros({(int64_t)log_exp_num, (int64_t)(phy_exp_num - log_exp_num + 1)}, cpu_i32)); phy2log = torch::zeros({(int64_t)phy_exp_num}, gpu_i32); size_t expert_per_ep = phy_exp_num / ep_size; @@ -32,8 +33,8 @@ void EplbPlanBuffers::init(size_t log_exp_num, if (quant_algo.isFp8()) { is_quantized = true; int group_size = quant_algo.getGroupSize(); - auto gpu_fp8 = torch::TensorOptions(torch::kFloat8_e4m3fn).device(torch::kCUDA); - auto gpu_fp32 = torch::TensorOptions(torch::kFloat32).device(torch::kCUDA); + auto gpu_fp8 = torch::TensorOptions(torch::kFloat8_e4m3fn).device(getTorchDevice()); + auto gpu_fp32 = torch::TensorOptions(torch::kFloat32).device(getTorchDevice()); moe_weight_1 = torch::zeros({(int64_t)expert_per_ep, (int64_t)(moe_size * 2), (int64_t)hidden_size}, gpu_fp8); moe_scale_1 = torch::zeros( @@ -44,7 +45,7 @@ void EplbPlanBuffers::init(size_t log_exp_num, {(int64_t)expert_per_ep, (int64_t)(hidden_size / group_size), (int64_t)(moe_size / group_size)}, gpu_fp32); } else { is_quantized = false; - auto gpu_dtype = torch::TensorOptions(dataTypeToTorchType(dtype)).device(torch::kCUDA); + auto gpu_dtype = torch::TensorOptions(dataTypeToTorchType(dtype)).device(getTorchDevice()); moe_weight_1 = torch::zeros({(int64_t)expert_per_ep, (int64_t)(moe_size * 2), (int64_t)hidden_size}, gpu_dtype); moe_weight_2 = torch::zeros({(int64_t)expert_per_ep, (int64_t)hidden_size, (int64_t)moe_size}, gpu_dtype); } @@ -56,8 +57,8 @@ void BalanceStatsBuffers::init(int layer_num, int log_exp_num, int ep_size) { gpu_loads = torch::zeros({layer_num, ep_size}, torch::kInt32); // gpu tensors - log_stats_gpu = torch::zeros({layer_num, log_exp_num}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); - gpu_loads_gpu = torch::zeros({layer_num, ep_size}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + log_stats_gpu = torch::zeros({layer_num, log_exp_num}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); + gpu_loads_gpu = torch::zeros({layer_num, ep_size}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); } void BalanceStatsBuffers::reset() { @@ -68,9 +69,9 @@ void BalanceStatsBuffers::reset() { } void LoadFlags::init() { - flag_gpu = torch::zeros({1}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); - flag_sync = torch::zeros({1}, torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); - flag_host = torch::zeros({1}, torch::kInt32).pin_memory(); + flag_gpu = torch::zeros({1}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); + flag_sync = torch::zeros({1}, torch::TensorOptions(torch::kInt32).device(getTorchDevice())); + flag_host = maybePinMemory(torch::zeros({1}, torch::kInt32)); } void LoadFlags::setReady(bool ready) { @@ -96,9 +97,9 @@ void EplbController::init(const EPLBConfig& eplb_control_data, const EPLBConfig& RTP_LLM_LOG_INFO("EPLB control step: %d", control_step); auto eplb_control_data_list = eplb_control_data.toList(); - eplb_control_data_buf_host = torch::zeros({(int64_t)eplb_control_data_list.size()}, torch::kInt32).pin_memory(); + eplb_control_data_buf_host = maybePinMemory(torch::zeros({(int64_t)eplb_control_data_list.size()}, torch::kInt32)); eplb_control_data_buf_device = torch::zeros({(int64_t)eplb_control_data_list.size()}, - torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + torch::TensorOptions(torch::kInt32).device(getTorchDevice())); } void EplbController::setData(const EPLBConfig& updated_control_data) { diff --git a/rtp_llm/cpp/models/logits_processor/BaseLogitsProcessor.cc b/rtp_llm/cpp/models/logits_processor/BaseLogitsProcessor.cc index cb27fdf7bb..4447129635 100644 --- a/rtp_llm/cpp/models/logits_processor/BaseLogitsProcessor.cc +++ b/rtp_llm/cpp/models/logits_processor/BaseLogitsProcessor.cc @@ -1,4 +1,5 @@ #include "rtp_llm/cpp/models/logits_processor/BaseLogitsProcessor.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/cpp/utils/AssertUtils.h" #if USING_CUDA #include "rtp_llm/models_py/bindings/cuda/ops/StandaloneOps.h" @@ -33,7 +34,7 @@ torch::Tensor BaseLogitsProcessor::generateVocabMask( } } - return vocab_mask_cpu.to(torch::kCUDA); + return vocab_mask_cpu.to(getTorchDevice()); } void BaseLogitsProcessor::maskLogits(torch::Tensor& new_tokens_logits, const torch::Tensor& vocab_mask) { RTP_LLM_CHECK(new_tokens_logits.dim() == 2); diff --git a/rtp_llm/cpp/models/logits_processor/MultiSeqLogitsProcessor.cc b/rtp_llm/cpp/models/logits_processor/MultiSeqLogitsProcessor.cc index 49402dc0f5..4eaba5c143 100644 --- a/rtp_llm/cpp/models/logits_processor/MultiSeqLogitsProcessor.cc +++ b/rtp_llm/cpp/models/logits_processor/MultiSeqLogitsProcessor.cc @@ -1,4 +1,5 @@ #include "rtp_llm/cpp/models/logits_processor/MultiSeqLogitsProcessor.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" namespace rtp_llm { @@ -39,7 +40,7 @@ void MultiSeqLogitsProcessor::process(const SamplerInputs& inputs, size_t start_ } } - auto logit_mask = logit_mask_host_tensor.to(torch::kCUDA); + auto logit_mask = logit_mask_host_tensor.to(getTorchDevice()); maskLogits(logits, logit_mask); } diff --git a/rtp_llm/cpp/normal_engine/NormalEngine.cc b/rtp_llm/cpp/normal_engine/NormalEngine.cc index 6effed3d6d..404d29db24 100644 --- a/rtp_llm/cpp/normal_engine/NormalEngine.cc +++ b/rtp_llm/cpp/normal_engine/NormalEngine.cc @@ -21,6 +21,8 @@ #if USING_CUDA #include "c10/cuda/CUDACachingAllocator.h" +#elif USING_XPU +#include #endif #ifdef __linux__ @@ -65,16 +67,22 @@ NormalEngine::NormalEngine(const EngineInitParams& params, + params.parallelism_config.tp_rank) { RTP_LLM_LOG_INFO(__PRETTY_FUNCTION__); #if !USING_CUDA - // On ROCm, this constructor runs on a gRPC handler thread that defaults to + // On ROCm/XPU, this constructor runs on a gRPC handler thread that defaults to // GPU 0. Set the correct device so all GPU allocations (KV cache, etc.) go // to the right device. The guard is scoped to the constructor body. +#if USING_XPU + c10::DeviceGuard ctor_device_guard( + c10::Device(c10::kXPU, static_cast(parallelism_config.local_rank))); + RTP_LLM_LOG_INFO("XPU NormalEngine ctor: set device to %d", parallelism_config.local_rank); +#else c10::DeviceGuard ctor_device_guard( c10::Device(c10::kCUDA, static_cast(parallelism_config.local_rank))); RTP_LLM_LOG_INFO("ROCm NormalEngine ctor: set device to %d", parallelism_config.local_rank); +#endif #endif std::optional warm_up_result = std::nullopt; -#if USING_CUDA +#if USING_CUDA || USING_XPU if (runtime_config.warm_up && (!model_config_.mm_model_config.is_multimodal) && !ffn_disaggregate_config.enable_ffn_disaggregate) { // warm up @@ -93,7 +101,7 @@ NormalEngine::NormalEngine(const EngineInitParams& params, RTP_LLM_LOG_INFO("skip warm up."); } #else - RTP_LLM_LOG_INFO("skip warm up on non-CUDA platform."); + RTP_LLM_LOG_INFO("skip warm up on non-CUDA/XPU platform."); #endif initCacheManager(warm_up_result); RTP_LLM_LOG_INFO("create cache manager done"); @@ -220,7 +228,7 @@ std::shared_ptr NormalEngine::makeFakeInput(size_t seq_len) { } WarmUpResult NormalEngine::prefillWarmUp(const EngineInitParams& params) { -#if !USING_CUDA +#if !USING_CUDA && !USING_XPU RTP_LLM_FAIL("prefillWarmUp is not supported on non-CUDA platforms"); return {}; #else @@ -234,15 +242,22 @@ WarmUpResult NormalEngine::prefillWarmUp(const EngineInitParams& params) { const auto max_consumed = getGpuExecStatus().device_memory_status.max_consumed_bytes; rtp_llm::setTraceMemory(false); (void)executor_.reset(nullptr); +#if USING_CUDA cudaDeviceSynchronize(); c10::cuda::CUDACachingAllocator::emptyCache(); +#elif USING_XPU + // XPU currently uses a single stream per device; synchronizing the current + // stream is sufficient to ensure all work is complete before emptyCache(). + c10::xpu::getCurrentXPUStream().synchronize(); + c10::xpu::XPUCachingAllocator::emptyCache(); +#endif const auto device_status = getGpuExecStatus(); return WarmUpResult({device_status.device_memory_status.available_bytes, max_consumed}); #endif } WarmUpResult NormalEngine::decodeWarmUp(const EngineInitParams& params) { -#if !USING_CUDA +#if !USING_CUDA && !USING_XPU RTP_LLM_FAIL("decodeWarmUp is not supported on non-CUDA platforms"); return {}; #else @@ -267,8 +282,15 @@ WarmUpResult NormalEngine::decodeWarmUp(const EngineInitParams& params) { const auto max_consumed = getGpuExecStatus().device_memory_status.max_consumed_bytes; rtp_llm::setTraceMemory(false); (void)executor_.reset(nullptr); +#if USING_CUDA cudaDeviceSynchronize(); c10::cuda::CUDACachingAllocator::emptyCache(); +#elif USING_XPU + // XPU currently uses a single stream per device; synchronizing the current + // stream is sufficient to ensure all work is complete before emptyCache(). + c10::xpu::getCurrentXPUStream().synchronize(); + c10::xpu::XPUCachingAllocator::emptyCache(); +#endif const auto device_status = getGpuExecStatus(); return WarmUpResult({device_status.device_memory_status.available_bytes, max_consumed}); #endif diff --git a/rtp_llm/cpp/normal_engine/NormalModelInputGatherer.cc b/rtp_llm/cpp/normal_engine/NormalModelInputGatherer.cc index 2d83fd50cd..12202c2ac5 100644 --- a/rtp_llm/cpp/normal_engine/NormalModelInputGatherer.cc +++ b/rtp_llm/cpp/normal_engine/NormalModelInputGatherer.cc @@ -6,6 +6,7 @@ #include "rtp_llm/cpp/normal_engine/NormalModelInputGatherer.h" #include "rtp_llm/cpp/utils/AssertUtils.h" #include "rtp_llm/cpp/utils/StatusUtil.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" namespace rtp_llm { @@ -172,8 +173,8 @@ void gatherMultimodalFeaturesForContextBatch(const GenerateStreamPtr& stream, } for (int i = reuse_mm_count; i < static_cast(mm_features.size()); ++i) { auto& mm_feature = mm_features[i]; - if (!mm_feature.is_cuda()) { - gathered_mm_features.emplace_back(mm_feature.to(torch::kCUDA)); + if (mm_feature.device() != getTorchDevice()) { + gathered_mm_features.emplace_back(mm_feature.to(getTorchDevice())); } else { gathered_mm_features.emplace_back(mm_feature); } @@ -370,7 +371,7 @@ absl::Status NormalModelInputGatherer::processContextStreams(GptModelInputs& stream->multimodalFeatures().size(), stream->streamId()); for (int j = reuse_mm_count; j < static_cast(mm_extra_input.size()); ++j) { - gathered_mm_extra_input.emplace_back(mm_extra_input[j].to(torch::kCUDA)); + gathered_mm_extra_input.emplace_back(mm_extra_input[j].to(getTorchDevice())); } } diff --git a/rtp_llm/cpp/normal_engine/NormalOutputDispatcher.cc b/rtp_llm/cpp/normal_engine/NormalOutputDispatcher.cc index 747d7b178e..f9f66a15df 100644 --- a/rtp_llm/cpp/normal_engine/NormalOutputDispatcher.cc +++ b/rtp_llm/cpp/normal_engine/NormalOutputDispatcher.cc @@ -1,4 +1,5 @@ #include "rtp_llm/cpp/normal_engine/NormalOutputDispatcher.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/cpp/engine_base/stream/GenerateStream.h" #include "rtp_llm/cpp/utils/AssertUtils.h" #include "rtp_llm/cpp/utils/TensorDebugUtils.h" @@ -116,7 +117,7 @@ void NormalOutputDispatcher::dispatchSingleStream(GenerateStreamPtr stream, auto tokens = stream->currentExecuteTokens(0); auto label_tensor = torch::from_blob(const_cast(tokens.data() + 1), {(int64_t)(tokens.size() - 1)}, torch::kInt32) - .to(torch::kCUDA); + .to(getTorchDevice()); auto labels_int64 = label_tensor.toType(torch::kInt64); loss = torch::cross_entropy_loss(all_logits_tensor, labels_int64, torch::nullopt, at::Reduction::None) .to(torch::kFloat32); diff --git a/rtp_llm/cpp/normal_engine/NormalSamplerInputGatherer.cc b/rtp_llm/cpp/normal_engine/NormalSamplerInputGatherer.cc index 9877a4a1e6..db787fa2d1 100644 --- a/rtp_llm/cpp/normal_engine/NormalSamplerInputGatherer.cc +++ b/rtp_llm/cpp/normal_engine/NormalSamplerInputGatherer.cc @@ -5,6 +5,7 @@ #include "rtp_llm/cpp/utils/AssertUtils.h" #include "rtp_llm/cpp/models/logits_processor/LogitsProcessorStates.h" #include "rtp_llm/cpp/utils/TensorDebugUtils.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" namespace rtp_llm { @@ -61,7 +62,7 @@ absl::StatusOr NormalSamplerInputGatherer::gather(const StreamGro sampler_inputs.vocab_size = vocab_size; if (return_all_probs != ReturnAllProbsMode::NONE) { sampler_inputs.all_probs = torch::zeros({(int64_t)total_batch_size_in, (int64_t)vocab_size}, - torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA)); + torch::TensorOptions().dtype(torch::kFloat32).device(getTorchDevice())); if (return_all_probs == ReturnAllProbsMode::ORIGINAL) { sampler_inputs.return_original_all_probs = true; } diff --git a/rtp_llm/cpp/normal_engine/speculative/MtpBatchStreamProcessor.cc b/rtp_llm/cpp/normal_engine/speculative/MtpBatchStreamProcessor.cc index 1b5d703ba8..0f47cb55c4 100644 --- a/rtp_llm/cpp/normal_engine/speculative/MtpBatchStreamProcessor.cc +++ b/rtp_llm/cpp/normal_engine/speculative/MtpBatchStreamProcessor.cc @@ -8,6 +8,7 @@ namespace rtp_llm { + absl::Status MtpBatchStreamProcessor::dispatchPrefill(const StreamGroups& stream_groups, const MergedOutput& prefill_output, const MergedOutput& propose_output) const { @@ -100,7 +101,7 @@ absl::StatusOr MtpBatchStreamProcessor::gatherSpecSamplerInput( auto vocab_size = (size_t)model_output.logits.size(1); if (return_all_probs != ReturnAllProbsMode::NONE) { sampler_inputs.all_probs = torch::zeros({(int64_t)total_batch_size, (int64_t)vocab_size}, - torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA)); + torch::TensorOptions().dtype(torch::kFloat32).device(getTorchDevice())); if (return_all_probs == ReturnAllProbsMode::ORIGINAL) { sampler_inputs.return_original_all_probs = true; } @@ -150,8 +151,8 @@ void MtpBatchStreamProcessor::prepareDecodeDraftModelInput(const StreamGroups& s size_t batch_size = stream_groups.size(); int batch_idx = 0; - auto combo_tokens = torch::empty({(int64_t)batch_size}, torch::kInt32).pin_memory(); - auto lm_output_indexes = torch::empty({(int64_t)batch_size}, torch::kInt32).pin_memory(); + auto combo_tokens = maybePinMemory(torch::empty({(int64_t)batch_size}, torch::kInt32)); + auto lm_output_indexes = maybePinMemory(torch::empty({(int64_t)batch_size}, torch::kInt32)); for (const auto& stream : stream_groups.allStreams()) { int propose_token = stream->getSPOutputBuffer()->tokens.data_ptr()[1]; @@ -169,11 +170,11 @@ void MtpBatchStreamProcessor::prepareOneStepSpecDecodeModelInput(const StreamGro size_t batch_size = stream_groups.size(); // prepare target model input buffer - auto target_prefix_lengths = model_input.sequence_lengths.cpu().clone().pin_memory(); + auto target_prefix_lengths = maybePinMemory(model_input.sequence_lengths.cpu().clone()); // allocate target_combo_tokens shape [batch_size, propose_step_ + 1] auto target_combo_tokens = - torch::empty({(int64_t)(stream_groups.size() * (propose_step_ + 1))}, torch::kInt32).pin_memory(); + maybePinMemory(torch::empty({(int64_t)(stream_groups.size() * (propose_step_ + 1))}, torch::kInt32)); // copy propose tokens to target_combo_tokens int batch_idx = 0; @@ -193,7 +194,7 @@ void MtpBatchStreamProcessor::prepareOneStepSpecDecodeModelInput(const StreamGro // update model_input model_input.combo_tokens = std::move(target_combo_tokens); model_input.prefix_lengths = target_prefix_lengths; - model_input.sequence_lengths = torch::empty({0}, torch::kInt32).pin_memory(); + model_input.sequence_lengths = maybePinMemory(torch::empty({0}, torch::kInt32)); model_input.last_hidden_states = torch::Tensor(); for (int i = 0; i < model_input.input_lengths.size(0); i++) { @@ -201,7 +202,7 @@ void MtpBatchStreamProcessor::prepareOneStepSpecDecodeModelInput(const StreamGro } // set lm_output_indexes - auto lm_output_indexes = torch::empty({(int64_t)(batch_size * (propose_step_ + 1))}, torch::kInt32).pin_memory(); + auto lm_output_indexes = maybePinMemory(torch::empty({(int64_t)(batch_size * (propose_step_ + 1))}, torch::kInt32)); for (int i = 0; i < batch_size * (propose_step_ + 1); i++) { lm_output_indexes.data_ptr()[i] = i; } @@ -217,7 +218,7 @@ void MtpBatchStreamProcessor::updateDecodeDraftModelInput(GptModelInputs& // here combo_tokens is a device buffer model_input.combo_tokens = draft_token_ids.reshape({batch_size}); - model_input.sequence_lengths = model_input.sequence_lengths.cpu().clone().pin_memory(); + model_input.sequence_lengths = maybePinMemory(model_input.sequence_lengths.cpu().clone()); for (int i = 0; i < batch_size; i++) { model_input.sequence_lengths.data_ptr()[i]++; } @@ -232,9 +233,9 @@ void MtpBatchStreamProcessor::updatePrefillPostDraftModelInput(GptModelInputs& // set model_input.combo_tokens const size_t batch_size = new_all_token_ids.size(0); const size_t token_stride = new_all_token_ids.size(1); - // token_ids may be a CUDA tensor; move to CPU for data_ptr access. + // token_ids may be a CUDA/XPU tensor; move to CPU for data_ptr access. const torch::Tensor new_all_token_ids_cpu = - new_all_token_ids.is_cuda() ? new_all_token_ids.cpu() : new_all_token_ids; + (new_all_token_ids.is_cuda() || new_all_token_ids.is_xpu()) ? new_all_token_ids.cpu() : new_all_token_ids; int* input_lengths = model_input.input_lengths.data_ptr(); int* combo_tokens = model_input.combo_tokens.data_ptr(); @@ -263,10 +264,10 @@ void MtpBatchStreamProcessor::updateDecodePostDraftModelInput( auto& accept_lens = speculative_sampler_output.accept_len; total_accept_len = std::accumulate(accept_lens.begin(), accept_lens.end(), 0); - model_input.combo_tokens = torch::empty({(int64_t)total_accept_len}, torch::kInt32).pin_memory(); + model_input.combo_tokens = maybePinMemory(torch::empty({(int64_t)total_accept_len}, torch::kInt32)); int token_offset = 0; - auto lm_output_indexes = torch::empty({(int64_t)batch_size}, torch::kInt32).pin_memory(); + auto lm_output_indexes = maybePinMemory(torch::empty({(int64_t)batch_size}, torch::kInt32)); std::vector hidden_states_list; for (int i = 0; i < batch_size; i++) { @@ -359,9 +360,9 @@ void MtpBatchStreamProcessor::preparePrefillSpecUpdateInfo(const StreamGroups& RTP_LLM_CHECK(total_batch_size_out == (size_t)new_all_token_ids.size(0)); const size_t token_stride = new_all_token_ids.size(1); - // token_ids and success may be CUDA tensors; move to CPU once before iterating. + // token_ids and success may be CUDA/XPU tensors; move to CPU once before iterating. const torch::Tensor new_all_token_ids_cpu = - new_all_token_ids.is_cuda() ? new_all_token_ids.cpu() : new_all_token_ids; + (new_all_token_ids.is_cuda() || new_all_token_ids.is_xpu()) ? new_all_token_ids.cpu() : new_all_token_ids; const torch::Tensor success_cpu = sampler_output.success.defined() ? sampler_output.success.cpu() : torch::Tensor(); int batch_idx_in = 0; @@ -388,7 +389,7 @@ void MtpBatchStreamProcessor::preparePrefillSpecUpdateInfo(const StreamGroups& // speculative decoding info torch::Tensor propose_all_probs = - draft_sampler_output.all_probs.narrow(0, batch_idx_out, next_batch_size).to(torch::kCUDA).clone(); + draft_sampler_output.all_probs.narrow(0, batch_idx_out, next_batch_size).to(getTorchDevice()).clone(); torch::Tensor last_hidden_states; if (propose_step_ > 1) { @@ -424,7 +425,7 @@ void MtpBatchStreamProcessor::prepareDecodeSpecUpdateInfo( // speculative decoding info torch::Tensor propose_all_probs = - draft_sampler_output.all_probs.narrow(0, batch_idx_out, next_batch_size).to(torch::kCUDA).clone(); + draft_sampler_output.all_probs.narrow(0, batch_idx_out, next_batch_size).to(getTorchDevice()).clone(); torch::Tensor last_hidden_states; if (propose_step_ > 1) { @@ -477,7 +478,7 @@ void MtpBatchStreamProcessor::gatherHiddenStates(const StreamGroups& stream_grou all_hidden_states = all_streams.front()->getSPOutputBuffer()->hidden_states; } else if (all_streams.size() < 8) { all_hidden_states = torch::empty({(int64_t)all_hidden_tokens_num, (int64_t)hidden_size}, - torch::TensorOptions().dtype(dtype).device(torch::kCUDA)); + torch::TensorOptions().dtype(dtype).device(getTorchDevice())); size_t index = 0; for (auto& stream : all_streams) { auto sp_output_buffer = stream->getSPOutputBuffer(); @@ -488,7 +489,7 @@ void MtpBatchStreamProcessor::gatherHiddenStates(const StreamGroups& stream_grou } } else { all_hidden_states = torch::empty({(int64_t)all_hidden_tokens_num, (int64_t)hidden_size}, - torch::TensorOptions().dtype(dtype).device(torch::kCUDA)); + torch::TensorOptions().dtype(dtype).device(getTorchDevice())); MultiMergeCopyParams params; params.dst_ptr = all_hidden_states.data_ptr(); diff --git a/rtp_llm/cpp/normal_engine/speculative/MtpExecutor.cc b/rtp_llm/cpp/normal_engine/speculative/MtpExecutor.cc index 9d9a1fe79d..10d1102394 100644 --- a/rtp_llm/cpp/normal_engine/speculative/MtpExecutor.cc +++ b/rtp_llm/cpp/normal_engine/speculative/MtpExecutor.cc @@ -22,6 +22,7 @@ namespace rtp_llm { + bool MtpExecutor::isTpRank0() const { return tp_rank_ == 0; } @@ -62,9 +63,9 @@ makeFakeSPOutputBuffer(DataType data_type, size_t hidden_size, size_t vocab_size auto sp_buffer = std::make_shared(); auto fake_hidden_states = torch::zeros( - {1, (int64_t)hidden_size}, torch::TensorOptions().dtype(dataTypeToTorchType(data_type)).device(torch::kCUDA)); + {1, (int64_t)hidden_size}, torch::TensorOptions().dtype(dataTypeToTorchType(data_type)).device(getTorchDevice())); auto fake_probs = - torch::zeros({1, (int64_t)vocab_size}, torch::TensorOptions().dtype(torch::kFloat).device(torch::kCUDA)); + torch::zeros({1, (int64_t)vocab_size}, torch::TensorOptions().dtype(torch::kFloat).device(getTorchDevice())); sp_buffer->propose_step = propose_step; sp_buffer->all_probs = fake_probs; sp_buffer->tokens = torch::zeros({1, 2}, torch::kInt32); @@ -538,8 +539,8 @@ absl::Status MtpExecutor::decodeStep(const std::list& streams if (!tensors_holder.empty()) { auto const& propose_probs = tensors_holder[0]; auto const& propose_hidden = tensors_holder[1]; - sp_output_buffer->all_probs = propose_probs.to(torch::kCUDA).clone(); - sp_output_buffer->hidden_states = propose_hidden.to(torch::kCUDA).clone(); + sp_output_buffer->all_probs = propose_probs.to(getTorchDevice()).clone(); + sp_output_buffer->hidden_states = propose_hidden.to(getTorchDevice()).clone(); } } } @@ -836,9 +837,9 @@ void MtpExecutor::draftModelDecode(GptModelInputs& model_input, // update TP > 0 batch_size size_t batch_size = model_input.combo_tokens.size(0); - spec_prefix_lengths = model_input.sequence_lengths.cpu().clone().pin_memory(); + spec_prefix_lengths = maybePinMemory(model_input.sequence_lengths.cpu().clone()); - auto pre_propose_token_t_raw = model_input.combo_tokens.to(torch::kCUDA).clone(); + auto pre_propose_token_t_raw = model_input.combo_tokens.to(getTorchDevice()).clone(); auto pre_target_token = torch::empty({(int64_t)batch_size}, torch::kInt32); int batch_idx = 0; @@ -848,7 +849,7 @@ void MtpExecutor::draftModelDecode(GptModelInputs& model_input, batch_idx++; } - auto pre_target_token_t = pre_target_token.to(torch::kCUDA); + auto pre_target_token_t = pre_target_token.to(getTorchDevice()); auto pre_target_token_t_reshape = pre_target_token_t.reshape({(int)batch_size, 1}); draft_token_ids_list.push_back(pre_target_token_t_reshape); @@ -873,7 +874,7 @@ void MtpExecutor::draftModelDecode(GptModelInputs& model_input, draft_decode_model_output.all_hidden_states.zero_(); } - draft_token_ids = draft_token_ids.to(torch::kInt32).to(torch::kCUDA); + draft_token_ids = draft_token_ids.to(torch::kInt32).to(getTorchDevice()); draft_token_ids_list.push_back(draft_token_ids); draft_probs_list.push_back(draft_probs_reshape); diff --git a/rtp_llm/cpp/normal_engine/speculative/SpeculativeSampler.cc b/rtp_llm/cpp/normal_engine/speculative/SpeculativeSampler.cc index 045dd71b87..f58cac3c72 100644 --- a/rtp_llm/cpp/normal_engine/speculative/SpeculativeSampler.cc +++ b/rtp_llm/cpp/normal_engine/speculative/SpeculativeSampler.cc @@ -34,14 +34,14 @@ void SpeculativeSampler::batchSample(SpeculativeSamplerOutput& sample_ const std::list& streams, SamplerOutput& draft_sampler_output, SamplerOutput& target_sampler_output) const { - torch::Device target_device = getTorchCudaDevice(); + torch::Device target_device = getTorchDevice(); torch::Device host_device = torch::Device(torch::kCPU); int batch_size = streams.size(); // target_sampler_output.token_ids may be a CUDA tensor (Sampler keeps it on GPU to avoid // D2H sync during sampling). Move to CPU once here for data_ptr access. - const torch::Tensor target_token_ids_cpu = target_sampler_output.token_ids.is_cuda() ? + const torch::Tensor target_token_ids_cpu = (target_sampler_output.token_ids.is_cuda() || target_sampler_output.token_ids.is_xpu()) ? target_sampler_output.token_ids.to(host_device, true) : target_sampler_output.token_ids; const int* new_all_token_ids = target_token_ids_cpu.data_ptr(); diff --git a/rtp_llm/cpp/pybind/BUILD b/rtp_llm/cpp/pybind/BUILD index 6ae2aeb9cb..6d33912c1c 100644 --- a/rtp_llm/cpp/pybind/BUILD +++ b/rtp_llm/cpp/pybind/BUILD @@ -53,6 +53,7 @@ cc_library( "ComputeInit.cc", ] + select({ "@//:using_cuda12": ["//rtp_llm/models_py/bindings/core:exec_ops_srcs"], + "@//:using_xpu": ["//rtp_llm/models_py/bindings/core:exec_ops_srcs"], "//conditions:default": [], }), hdrs = [], @@ -65,6 +66,29 @@ cc_library( ] + torch_deps() + select_py_bindings() + select({ "@//:using_cuda12": ["//rtp_llm/models_py/bindings/cuda/ops:gpu_base"], "@//:using_rocm": ["//rtp_llm/models_py/bindings/core:exec_ctx_rocm"], + "@//:using_xpu": [ + "//rtp_llm/models_py/bindings/core:exec_ops_hdr", + "//rtp_llm/models_py/bindings/core:exec_ctx_ops", + "//rtp_llm/models_py/bindings/core:device_data", + "//rtp_llm/models_py/bindings/core:op_data", + "//rtp_llm/models_py/bindings/core:type_convert", + "//rtp_llm/models_py/bindings/core:types_hdr", + "//rtp_llm/models_py/bindings/core:common_defines", + "//rtp_llm/cpp/utils:signal_utils", + "//rtp_llm/cpp/utils:kv_cache_utils", + "//rtp_llm/cpp/config:static_config", + "//rtp_llm/cpp/model_utils:model_utils", + "//rtp_llm/cpp/config:config_modules", + "//rtp_llm/models_py/bindings:op_defs", + "//rtp_llm/cpp/models:stats", + "//rtp_llm/cpp/models/models_weight:weights_define", + "//rtp_llm/cpp/cache:cache_group_type", + "//rtp_llm/cpp/pybind:th_utils", + "//rtp_llm/cpp/disaggregate/cache_store:cache_store_interface", + "@havenask//aios/autil:stack_tracer", + "@havenask//aios/autil:string_helper", + "@havenask//aios/autil:scope", + ], "//conditions:default": [], }) + no_block_copy_link_deps(), copts = copts(), @@ -106,6 +130,10 @@ cc_library( "//rtp_llm/models_py/bindings/core:exec_ops_hdr", "//rtp_llm/cpp/cuda_graph:cuda_graph_impl", ], + "@//:using_xpu": [ + "//rtp_llm/models_py/bindings/core:exec_ctx_ops", + "//rtp_llm/models_py/bindings/core:exec_ops_hdr", + ], "//conditions:default": [], }), copts = copts(), diff --git a/rtp_llm/cpp/pybind/ComputeInit.cc b/rtp_llm/cpp/pybind/ComputeInit.cc index 62c9fb3628..30ea367cce 100644 --- a/rtp_llm/cpp/pybind/ComputeInit.cc +++ b/rtp_llm/cpp/pybind/ComputeInit.cc @@ -8,7 +8,7 @@ #include "pybind11/cast.h" #include "pybind11/stl.h" -#if USING_CUDA || USING_ROCM +#if USING_CUDA || USING_ROCM || USING_XPU #endif namespace rtp_llm { @@ -16,7 +16,7 @@ void registerExecCtxOps(pybind11::module& m); using namespace torch_ext; PYBIND11_MODULE(librtp_compute_ops, m) { -#if USING_CUDA || USING_ROCM +#if USING_CUDA || USING_ROCM || USING_XPU registerExecCtxOps(m); #endif diff --git a/rtp_llm/cpp/pybind/th_utils.h b/rtp_llm/cpp/pybind/th_utils.h index bdd19e7f16..a711a2c22d 100644 --- a/rtp_llm/cpp/pybind/th_utils.h +++ b/rtp_llm/cpp/pybind/th_utils.h @@ -41,8 +41,13 @@ #endif #define CHECK_TYPE(x, st) TORCH_CHECK(x.scalar_type() == st, "Inconsistency of Tensor type: " #x) +#if USING_XPU +#define CHECK_TH_CUDA(x) TORCH_CHECK(x.is_xpu(), #x " must be an XPU tensor") +#define CHECK_CPU(x) TORCH_CHECK(x.is_cpu(), #x " must be a CPU tensor") +#else #define CHECK_TH_CUDA(x) TORCH_CHECK(x.is_cuda(), #x " must be a CUDA tensor") -#define CHECK_CPU(x) TORCH_CHECK(!x.is_cuda(), #x " must be a CPU tensor") +#define CHECK_CPU(x) TORCH_CHECK(x.is_cpu(), #x " must be a CPU tensor") +#endif #define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") #define CHECK_INPUT(x, st) \ CHECK_TH_CUDA(x); \ diff --git a/rtp_llm/cpp/utils/ErrorCode.h b/rtp_llm/cpp/utils/ErrorCode.h index 47d0c62f9b..551bca5b80 100644 --- a/rtp_llm/cpp/utils/ErrorCode.h +++ b/rtp_llm/cpp/utils/ErrorCode.h @@ -1,4 +1,6 @@ #pragma once +// XPU toolchain does not transitively include ; needed by ErrorInfo/ErrorCodeToString. +#include namespace rtp_llm { diff --git a/rtp_llm/cpp/utils/TensorDebugUtils.h b/rtp_llm/cpp/utils/TensorDebugUtils.h index f375a6b63c..36a4ec9650 100644 --- a/rtp_llm/cpp/utils/TensorDebugUtils.h +++ b/rtp_llm/cpp/utils/TensorDebugUtils.h @@ -26,7 +26,7 @@ std::string tensorDebugStringWithData(const torch::Tensor& t, size_t count = 0) if (!t.defined()) return "(undefined)"; auto meta = tensorDebugString(t); - if (t.is_cuda()) + if (t.is_cuda() || t.is_xpu()) return meta + ", Device tensor data can NOT be dumped"; auto cpu_t = t.contiguous(); auto base = cpu_t.data_ptr(); diff --git a/rtp_llm/device/__init__.py b/rtp_llm/device/__init__.py index 3df4efe466..c9ae035d9e 100644 --- a/rtp_llm/device/__init__.py +++ b/rtp_llm/device/__init__.py @@ -2,7 +2,7 @@ from typing import Optional, Type from rtp_llm.device.device_base import DeviceBase -from rtp_llm.device.device_impl import ArmCpuImpl, CpuImpl, CudaImpl, PpuImpl, RocmImpl +from rtp_llm.device.device_impl import ArmCpuImpl, CpuImpl, CudaImpl, PpuImpl, RocmImpl, XpuImpl from rtp_llm.device.device_type import DeviceType, get_device_type _current_device: Optional[DeviceBase] = None @@ -19,6 +19,8 @@ def get_device_cls(type: DeviceType) -> Type: return PpuImpl elif type == DeviceType.ROCm: return RocmImpl + elif type == DeviceType.Xpu: + return XpuImpl else: raise ValueError(f"Invalid device type {type}") diff --git a/rtp_llm/device/device_impl.py b/rtp_llm/device/device_impl.py index e1768c7d63..1bc5439aad 100644 --- a/rtp_llm/device/device_impl.py +++ b/rtp_llm/device/device_impl.py @@ -1016,3 +1016,198 @@ def convert_fp8_weight_params( # https://onnx.ai/onnx/technical/float8.html weight_scale = weight_scale * 2.0 return weight, weight_scale + + +class XpuImpl(GpuImpl): + """Intel XPU (GPU) device implementation using PyTorch XPU backend.""" + + def __init__(self): + super().__init__() + + def get_device_id(self) -> int: + try: + return torch.xpu.current_device() + except Exception as e: + logger = logging.getLogger(__name__) + # current_device() can fail before set_device() has run. Rather than + # blindly targeting device 0 (wrong on a multi-card box and a silent + # source of cross-device corruption), derive the id from LOCAL_RANK + # honoured against the visible-device mask (ZE_AFFINITY_MASK). + try: + local_rank = int(os.environ.get("LOCAL_RANK", "0")) + visible = get_visible_device_list() + if visible and local_rank < len(visible): + dev_id = int(visible[local_rank]) + logger.warning( + "XPU current_device() failed (%s); using device %d " + "derived from LOCAL_RANK=%d and visible list %s", + e, dev_id, local_rank, visible) + return dev_id + except Exception as inner: + logger.warning("XPU device-id derivation failed (%s)", inner) + raise RuntimeError( + f"XPU current_device() failed ({e}) and device id could not be " + f"derived from LOCAL_RANK={os.environ.get('LOCAL_RANK', '')}" + f"/ZE_AFFINITY_MASK={os.environ.get('ZE_AFFINITY_MASK', '')}. " + f"Ensure torch.xpu.set_device() is called before model init.") + + def _get_mem_info(self) -> MemInfo: + dev_id = self.get_device_id() + free, total = torch.xpu.mem_get_info(dev_id) + return MemInfo(used=total - free, free=free) + + @property + def arch(self) -> str: + try: + dev_id = self.get_device_id() + name = torch.xpu.get_device_name(dev_id) + return name + except Exception as e: + logging.warning(f"Cannot get XPU device name: {e}") + return "unknown_xpu" + + def preprocess_weights_for_mixed_gemm( + self, + tensor: torch.Tensor, + quant_mode: torch.dtype, + arch: str = "", + ) -> torch.Tensor: + # XPU has no kernel for weight-only mixed-GEMM quantization preprocessing. + # This path is only ever reached with a weight that needs CUDA-specific + # reordering (INT8/INT4, and any future quant dtype). Fail fast for every + # quant_mode (whitelist of none) instead of silently returning an + # unprocessed tensor, which would produce wrong inference results. + raise NotImplementedError( + f"Weight quantization format {quant_mode} is not supported on XPU. " + "Please use a non-quantized (FP16/BF16) or FP8 model." + ) + + +# ── Device-agnostic utility functions ────────────────────────────────────── + +def _is_xpu_device() -> bool: + """Check if the resolved device type is XPU, respecting RTP_LLM_DEVICE_TYPE override.""" + from rtp_llm.device.device_type import get_device_type, DeviceType + return get_device_type() == DeviceType.Xpu + + +def _is_cuda_device() -> bool: + """Check if the resolved device type is CUDA/ROCm (not XPU), respecting RTP_LLM_DEVICE_TYPE.""" + from rtp_llm.device.device_type import get_device_type, DeviceType + dt = get_device_type() + return dt in (DeviceType.Cuda, DeviceType.ROCm, DeviceType.Ppu) + + +def gpu_is_available() -> bool: + """Check if the resolved GPU backend is actually usable. + + Honors the resolved device type (RTP_LLM_DEVICE_TYPE) but reports real + availability, so a forced-but-unusable backend reads as unavailable rather + than silently True. + """ + if _is_xpu_device(): + return (hasattr(torch, "xpu") and torch.xpu.is_available() + and torch.xpu.device_count() > 0) + if _is_cuda_device(): + return torch.cuda.is_available() + return False + + +def gpu_device_count() -> int: + """Return the number of available GPU devices. + + Raises a clear error when the resolved device type is forced via + RTP_LLM_DEVICE_TYPE but the backend is not actually usable. + """ + if _is_xpu_device(): + if not (hasattr(torch, "xpu") and torch.xpu.is_available()): + raise RuntimeError( + "Resolved device type is XPU but torch.xpu is not available. " + "Check RTP_LLM_DEVICE_TYPE / ZE_AFFINITY_MASK and the torch XPU " + "build.") + return torch.xpu.device_count() + if _is_cuda_device(): + if not torch.cuda.is_available(): + raise RuntimeError( + "Resolved device type is CUDA but torch.cuda is not available. " + "Check RTP_LLM_DEVICE_TYPE / CUDA_VISIBLE_DEVICES and the torch " + "CUDA build.") + return torch.cuda.device_count() + return 0 + + +def gpu_set_device(device_id: int) -> None: + """Set the current GPU device.""" + if _is_xpu_device(): + if not (hasattr(torch, "xpu") and torch.xpu.is_available() + and torch.xpu.device_count() > 0): + raise RuntimeError( + "Resolved device type is XPU but no usable torch.xpu device is " + "available. Check RTP_LLM_DEVICE_TYPE / ZE_AFFINITY_MASK and the " + "torch XPU build.") + torch.xpu.set_device(device_id) + elif _is_cuda_device(): + if not torch.cuda.is_available(): + raise RuntimeError( + "Resolved device type is CUDA but torch.cuda is not available. " + "Check RTP_LLM_DEVICE_TYPE / CUDA_VISIBLE_DEVICES and the torch " + "CUDA build.") + torch.cuda.set_device(device_id) + + +def gpu_current_device() -> int: + """Get the current GPU device index.""" + if _is_xpu_device(): + return torch.xpu.current_device() + if _is_cuda_device(): + return torch.cuda.current_device() + return 0 + + +def gpu_device_name(device_id: int = 0) -> str: + """Get the name of a GPU device.""" + if _is_xpu_device(): + return torch.xpu.get_device_name(device_id) + if _is_cuda_device(): + return torch.cuda.get_device_name(device_id) + return "cpu" + + +def gpu_memory_info(device_id: int = 0): + """Return (free, total) memory in bytes for the GPU device.""" + if _is_xpu_device(): + return torch.xpu.mem_get_info(device_id) + if _is_cuda_device(): + return torch.cuda.mem_get_info(device_id) + import psutil + vmem = psutil.virtual_memory() + return (vmem.available, vmem.total) + + +def get_device_string() -> str: + """Return the device string for tensor placement ('cuda', 'xpu', or 'cpu').""" + if _is_xpu_device(): + return "xpu" + if _is_cuda_device(): + return "cuda" + return "cpu" + + +def get_visible_device_list(): + """Get list of visible device indices from environment or hardware detection.""" + import os + # Honor the resolved device type (RTP_LLM_DEVICE_TYPE) rather than raw + # hardware presence, so a CUDA override on a mixed host does not read the + # XPU affinity mask (and vice versa). + if _is_xpu_device(): + xpu_mask = os.environ.get("ZE_AFFINITY_MASK", None) + if xpu_mask is not None and xpu_mask.strip(): + # ZE_AFFINITY_MASK may use dotted format "0.0,1.0" for sub-devices; + # extract only the device portion (before the dot) for indexing. + return [e.split(".")[0] for e in xpu_mask.split(",")] + elif _is_cuda_device(): + cuda_devices = os.environ.get("CUDA_VISIBLE_DEVICES", None) + if cuda_devices is not None: + return cuda_devices.split(",") + + return [str(i) for i in range(gpu_device_count())] diff --git a/rtp_llm/device/device_type.py b/rtp_llm/device/device_type.py index 7efea2c565..8b40a17dfb 100644 --- a/rtp_llm/device/device_type.py +++ b/rtp_llm/device/device_type.py @@ -11,10 +11,58 @@ class DeviceType(IntEnum): ArmCpu = 3 ROCm = 4 Ppu = 5 + Xpu = 6 + + +_DEVICE_TYPE_OVERRIDE = { + "cpu": DeviceType.Cpu, + "cuda": DeviceType.Cuda, + "yitian": DeviceType.Yitian, + "armcpu": DeviceType.ArmCpu, + "rocm": DeviceType.ROCm, + "ppu": DeviceType.Ppu, + "xpu": DeviceType.Xpu, +} + + +_DEVICE_TYPE_CACHE = {} def get_device_type() -> DeviceType: - if torch.cuda.is_available(): + # Cache the resolved type per RTP_LLM_DEVICE_TYPE value so the torch + # xpu/cuda probing and the mixed-device warning run once per process + # (RTP_LLM_DEVICE_TYPE only needs to be set before startup). Keying on the + # override value still lets a process that changes the env re-resolve. + override = os.environ.get("RTP_LLM_DEVICE_TYPE", "").strip().lower() + cached = _DEVICE_TYPE_CACHE.get(override) + if cached is not None: + return cached + resolved = _resolve_device_type(override) + _DEVICE_TYPE_CACHE[override] = resolved + return resolved + + +def _resolve_device_type(override: str) -> DeviceType: + # Explicit override wins so a mixed XPU+CUDA host is never silently + # resolved by detection-order alone. Set RTP_LLM_DEVICE_TYPE=cuda|xpu|... + if override: + if override in _DEVICE_TYPE_OVERRIDE: + return _DEVICE_TYPE_OVERRIDE[override] + raise ValueError( + f"Unknown RTP_LLM_DEVICE_TYPE={override!r}; valid values: " + f"{sorted(_DEVICE_TYPE_OVERRIDE.keys())}") + + xpu_available = hasattr(torch, "xpu") and torch.xpu.is_available() + cuda_available = torch.cuda.is_available() + if xpu_available and cuda_available: + # Both backends visible and no explicit override: prefer CUDA so an + # existing CUDA deployment that merely has XPU libraries present is not + # silently switched to XPU. Set RTP_LLM_DEVICE_TYPE=xpu to force XPU. + import logging + logging.getLogger(__name__).warning( + "Both XPU and CUDA are available; selecting CUDA by default. " + "Set RTP_LLM_DEVICE_TYPE=xpu to force XPU.") + if cuda_available: if hasattr(torch.version, "hip") and torch.version.hip is not None: return DeviceType.ROCm if ( @@ -23,6 +71,8 @@ def get_device_type() -> DeviceType: ): return DeviceType.Ppu return DeviceType.Cuda + if xpu_available: + return DeviceType.Xpu return DeviceType.Cpu @@ -32,3 +82,7 @@ def is_cuda() -> bool: def is_hip() -> bool: return get_device_type() == DeviceType.ROCm + + +def is_xpu() -> bool: + return get_device_type() == DeviceType.Xpu diff --git a/rtp_llm/frontend/frontend_app.py b/rtp_llm/frontend/frontend_app.py index c075566d1d..2056a3a561 100644 --- a/rtp_llm/frontend/frontend_app.py +++ b/rtp_llm/frontend/frontend_app.py @@ -18,7 +18,10 @@ from fastapi.responses import ORJSONResponse from typing_extensions import override from uvicorn import Config, Server -from uvicorn.loops.auto import auto_loop_setup +try: + from uvicorn.loops.auto import auto_loop_setup +except ImportError: + from uvicorn.loops.auto import auto_loop_factory as auto_loop_setup from rtp_llm.config.engine_config import EngineConfig from rtp_llm.config.py_config_modules import PyEnvConfigs diff --git a/rtp_llm/model_loader/loader.py b/rtp_llm/model_loader/loader.py index 911105b56e..c091ab1a5d 100644 --- a/rtp_llm/model_loader/loader.py +++ b/rtp_llm/model_loader/loader.py @@ -22,6 +22,7 @@ from rtp_llm.model_loader.weight_module import CustomAtomicWeight, WeightModule from rtp_llm.ops import TaskType, VitSeparation from rtp_llm.utils.database import BaseDatabase, CkptDatabase +from rtp_llm.device.device_impl import gpu_is_available from rtp_llm.utils.model_weight import W, WeightStyle, identity from rtp_llm.utils.module_util import has_module from rtp_llm.utils.time_util import timer_wrapper @@ -415,11 +416,16 @@ def _load_from_fastsafetensor(self, device: str): else: complete = weight_info.collector.store_tensor(key, loaded_tensor) - if inline_fp8 and _total_count % 500 == 0 and torch.cuda.is_available(): - torch.cuda.empty_cache() - if _total_count % 5000 == 0 and torch.cuda.is_available(): - alloc_gb = torch.cuda.memory_allocated() / (1024**3) - reserved_gb = torch.cuda.memory_reserved() / (1024**3) + if inline_fp8 and _total_count % 500 == 0: + ModelLoader.force_clean_cuda_memory() + if _total_count % 5000 == 0 and gpu_is_available(): + from rtp_llm.device.device_impl import _is_xpu_device + if _is_xpu_device(): + alloc_gb = torch.xpu.memory_allocated() / (1024**3) + reserved_gb = torch.xpu.memory_reserved() / (1024**3) + else: + alloc_gb = torch.cuda.memory_allocated() / (1024**3) + reserved_gb = torch.cuda.memory_reserved() / (1024**3) logging.info( f"fastsafetensor loading progress: {_total_count} tensors, " f"{_inline_count} inline-fp8, " @@ -441,7 +447,7 @@ def _load_from_fastsafetensor(self, device: str): model_weights.set_global_weight(name, tensor) weight_info.collector.clear() if inline_fp8: - torch.cuda.empty_cache() + ModelLoader.force_clean_cuda_memory() gc.collect() _fallback_count = 0 @@ -558,8 +564,12 @@ def _maybe_skip_weight(self, weight: WeightModule): @staticmethod def force_clean_cuda_memory(): """安全清理显存，避免残留引用""" + from rtp_llm.device.device_impl import _is_cuda_device, _is_xpu_device gc.collect() - if torch.cuda.is_available(): + if _is_xpu_device(): + torch.xpu.synchronize() + torch.xpu.empty_cache() + elif _is_cuda_device(): torch.cuda.synchronize() torch.cuda.empty_cache() diff --git a/rtp_llm/model_loader/weight_manager.py b/rtp_llm/model_loader/weight_manager.py index 04f863ae5a..2c971a1491 100644 --- a/rtp_llm/model_loader/weight_manager.py +++ b/rtp_llm/model_loader/weight_manager.py @@ -7,6 +7,7 @@ import torch +from rtp_llm.device.device_impl import _is_xpu_device from rtp_llm.model_loader.loader import ModelLoader from rtp_llm.model_loader.model_weight_info import ModelWeights @@ -112,9 +113,17 @@ def __init__( self._weights: ModelWeights = weight self._weights_loader: ModelLoader = model_weights_loader self._weight_module = self._weights_loader._model_weights_info - self._working_stream: torch.cuda.Stream = torch.cuda.Stream( - device=self._device, - ) + # Respect RTP_LLM_DEVICE_TYPE: only skip the CUDA stream when the + # resolved device is actually XPU, not merely when XPU hardware exists. + if _is_xpu_device(): + # XPU currently operates on a single default stream; creating a + # separate stream is not needed. torch.xpu.synchronize() in the + # update path is acceptable since weight updates are infrequent. + self._working_stream = None + else: + self._working_stream: torch.cuda.Stream = torch.cuda.Stream( + device=self._device, + ) # TODO: Consider the actual need for this lock. If updates are always # serialized via the server's request handling, a per-update lock might # be redundant or require finer-grained locking within _weights.update_... @@ -193,6 +202,8 @@ def update(self, req: dict[str, str]) -> None: tensor: torch.Tensor | None = None if method == "cuda_ipc": + if _is_xpu_device(): + raise ValueError("cuda_ipc is not supported on XPU; use method='shm'") helper = CudaIpcHelper() tensor = helper.build_from_meta(bytes.fromhex(desc)) else: # method == "shm" @@ -211,7 +222,12 @@ def update(self, req: dict[str, str]) -> None: logging.info( f"update weight request: {name}, shape: {tensor.shape}, device: {tensor.device}, dtype: {tensor.dtype}" ) - with torch.cuda.stream(self._working_stream): + if self._working_stream is not None: + stream_ctx = torch.cuda.stream(self._working_stream) + else: + import contextlib + stream_ctx = contextlib.nullcontext() + with stream_ctx: config = self._weights_loader.get_load_config() if "layers" in name: # This is a layer-specific weight @@ -273,4 +289,7 @@ def update(self, req: dict[str, str]) -> None: f"{stored_name} not found. wanted name list is {[w.name for w in self._weight_module.weights]}" ) - self._working_stream.synchronize() + if self._working_stream is not None: + self._working_stream.synchronize() + elif _is_xpu_device(): + torch.xpu.synchronize() diff --git a/rtp_llm/models/base_model.py b/rtp_llm/models/base_model.py index 1e7160a5cc..0677314db7 100644 --- a/rtp_llm/models/base_model.py +++ b/rtp_llm/models/base_model.py @@ -123,7 +123,11 @@ def load_default_generate_config(self, generate_env_config: Optional[Any] = None def _get_device_str(self) -> str: """Get device string from parallelism_config.""" - return f"cuda:{self.parallelism_config.local_rank}" + # Use the resolved device type (respects RTP_LLM_DEVICE_TYPE) rather + # than unconditionally preferring XPU when torch.xpu is available, so a + # mixed XPU+CUDA host can be pinned to the operator-selected backend. + from rtp_llm.device.device_impl import get_device_string + return f"{get_device_string()}:{self.parallelism_config.local_rank}" @timer_wrapper(description="load model") def load(self, skip_python_model: bool = False): diff --git a/rtp_llm/models_py/bindings/OpDefs.cc b/rtp_llm/models_py/bindings/OpDefs.cc index a70dd00bf4..c3c150992e 100644 --- a/rtp_llm/models_py/bindings/OpDefs.cc +++ b/rtp_llm/models_py/bindings/OpDefs.cc @@ -121,6 +121,9 @@ void registerPyOpDefs(pybind11::module& m) { .def_readwrite("cache_store_inputs", &PyAttentionInputs::cache_store_inputs) .def_readwrite("context_parallel_info", &PyAttentionInputs::context_parallel_info) .def_readwrite("combo_position_ids", &PyAttentionInputs::combo_position_ids) +#if USING_XPU + .def_readwrite("position_ids", &PyAttentionInputs::position_ids) +#endif .def("__repr__", [](const PyAttentionInputs& self) { return "PyAttentionInputs"; }) .def_readwrite("prefill_cuda_graph_copy_params", &PyAttentionInputs::prefill_cuda_graph_copy_params) .def_readwrite("headwise_config", &PyAttentionInputs::headwise_config) diff --git a/rtp_llm/models_py/bindings/OpDefs.h b/rtp_llm/models_py/bindings/OpDefs.h index 8b67ba86b4..26ad9ac733 100644 --- a/rtp_llm/models_py/bindings/OpDefs.h +++ b/rtp_llm/models_py/bindings/OpDefs.h @@ -83,12 +83,26 @@ struct KVCache { (int64_t)kernel_seq_size_per_block, (int64_t)(kv_lora_rank + rope_head_dim)}); } else if (num_kv_heads > 0 && head_dim > 0) { +#if USING_XPU + // XPU flash layout (NSHD): [kernel_block_num, 2, kernel_seq_size_per_block, num_kv_heads, head_dim] + // Seq-before-head so paged flash attention can gather with no transpose. + // SOLE CONSUMER: rtp_llm/models_py/modules/factory/attention/xpu_impl/vllm_flash_attn.py + // (_read_from_paged_cache / _write_to_paged_cache / XpuVllm{Prefill,Decode}Impl), + // which index cache[block, k/v, seq_offset, head, dim]. Keep this layout and that + // consumer in sync; covered by xpu_impl/test/test_kv_cache_layout.py. + layer_cache.kv_cache_base = base.reshape({kernel_block_num, + 2, + (int64_t)kernel_seq_size_per_block, + (int64_t)num_kv_heads, + (int64_t)head_dim}); +#else // MHA layout: [kernel_block_num, 2, num_kv_heads, kernel_seq_size_per_block, head_dim] layer_cache.kv_cache_base = base.reshape({kernel_block_num, 2, (int64_t)num_kv_heads, (int64_t)kernel_seq_size_per_block, (int64_t)head_dim}); +#endif } else { layer_cache.kv_cache_base = base; } @@ -189,7 +203,10 @@ struct PyAttentionInputs { int total_tokens = 0; torch::Tensor padding_offset; torch::Tensor combo_position_ids; - +#if USING_XPU + // XPU: per-token RoPE position ids, cached across layers within one forward pass. + torch::Tensor position_ids; +#endif // for write cache store std::optional cache_store_inputs; diff --git a/rtp_llm/models_py/bindings/common/BUILD b/rtp_llm/models_py/bindings/common/BUILD index c0c1036666..45a2a89324 100644 --- a/rtp_llm/models_py/bindings/common/BUILD +++ b/rtp_llm/models_py/bindings/common/BUILD @@ -8,17 +8,23 @@ cc_library( deps = [ "//rtp_llm/models_py/bindings/core:exec_ops_hdr", "//rtp_llm/models_py/bindings/core:types_hdr", - "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", ] + torch_deps() + select({ "//:using_cuda": [ + "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", "@local_config_cuda//cuda:cuda_headers", "@local_config_cuda//cuda:cudart", ], "//:using_rocm": [ + "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", "@local_config_rocm//rocm:rocm_headers", "@local_config_rocm//rocm:rocm", "//rtp_llm/models_py/bindings/rocm:rocm_types_hdr", ], + "//:using_xpu": [], + "//conditions:default": [], + }), + features = select({ + "//:using_xpu": ["xpu_sycl_compile"], "//conditions:default": [], }), visibility = ["//visibility:public"], @@ -28,24 +34,54 @@ cc_library( cc_library( name = "common", - srcs = glob(["*.cc"], exclude = ["FusedCopyOp.cc"]), + srcs = glob( + ["*.cc"], + exclude = [ + "CudaGraphPrefillCopy.cc", + "FusedCopyOp.cc", + "FusedQKRmsNorm.cc", + "RtpEmbeddingLookup.cc", + "RtpNorm.cc", + ], + ) + select({ + "//:using_cuda": [ + "CudaGraphPrefillCopy.cc", + "FusedQKRmsNorm.cc", + "RtpEmbeddingLookup.cc", + "RtpNorm.cc", + ], + "//:using_rocm": [ + "CudaGraphPrefillCopy.cc", + "FusedQKRmsNorm.cc", + "RtpEmbeddingLookup.cc", + "RtpNorm.cc", + ], + "//:using_xpu": [], + "//conditions:default": [], + }), hdrs = glob(["*.h"]), deps = [ - ":fuse_copy_op", "//rtp_llm/models_py/bindings:op_defs", "//rtp_llm/models_py/bindings/core:op_data", "//rtp_llm/models_py/bindings/core:exec_ops_hdr", "//rtp_llm/models_py/bindings/core:cache_store_async_writer", - "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", + "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_util", ] + torch_deps() + select({ "//:using_cuda": [ + ":fuse_copy_op", + "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", "//rtp_llm/models_py/bindings/common/kernels:kernels_cu", "//rtp_llm/models_py/bindings/cuda/ops:cuda_impl", ], "//:using_rocm": [ + ":fuse_copy_op", + "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_kernel", "//rtp_llm/models_py/bindings/common/kernels:kernels_cu", "//rtp_llm/models_py/bindings/core:exec_ctx_rocm", ], + "//:using_xpu": [ + ":fuse_copy_op", + ], "//conditions:default": [], }), visibility = ["//visibility:public"], diff --git a/rtp_llm/models_py/bindings/common/FusedCopyOp.cc b/rtp_llm/models_py/bindings/common/FusedCopyOp.cc index 16377a56ce..1eddfe3dcf 100644 --- a/rtp_llm/models_py/bindings/common/FusedCopyOp.cc +++ b/rtp_llm/models_py/bindings/common/FusedCopyOp.cc @@ -1,41 +1,82 @@ #include "rtp_llm/models_py/bindings/core/ExecOps.h" #include "rtp_llm/models_py/bindings/core/Types.h" -#include "rtp_llm/models_py/bindings/common/kernels/fuse_copy_kernel.h" #if USING_CUDA +#include "rtp_llm/models_py/bindings/common/kernels/fuse_copy_kernel.h" #include #include #endif #if USING_ROCM +#include "rtp_llm/models_py/bindings/common/kernels/fuse_copy_kernel.h" #include #include "rtp_llm/models_py/bindings/rocm/cuda_shims.h" #include #endif +#if USING_XPU +#include +#include +#include +#endif + +#include "rtp_llm/cpp/utils/AssertUtils.h" namespace rtp_llm { void fusedCopy(const FusedD2DCopyParams& params) { #if USING_CUDA cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + invokeFusedCopy(params, stream); #elif USING_ROCM hipStream_t stream = at::hip::getCurrentHIPStream(); + invokeFusedCopy(params, stream); +#elif USING_XPU + // XPU fallback: sequential async memcpy via SYCL queue + RTP_LLM_CHECK(params.num_copies >= 0 && params.num_copies <= MAX_FUSED_D2D_COPIES); + sycl::queue& queue = c10::xpu::getCurrentXPUStream(); + for (int i = 0; i < params.num_copies; ++i) { + RTP_LLM_CHECK(params.dst[i] != nullptr && params.src[i] != nullptr); + if (params.size[i] == 0) continue; + queue.memcpy(params.dst[i], params.src[i], params.size[i]); + } #else throw std::runtime_error("No supported GPU backend found for fusedCopy"); - return; #endif - invokeFusedCopy(params, stream); } void fusedStridedCopy(const FusedStridedCopyParams& params) { #if USING_CUDA cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + invokeFusedStridedCopy(params, stream); #elif USING_ROCM hipStream_t stream = at::hip::getCurrentHIPStream(); + invokeFusedStridedCopy(params, stream); +#elif USING_XPU + // XPU: async strided memcpy via SYCL queue. + // When rows are contiguous (stride == row_bytes), merge into a single memcpy + // to reduce queue submission overhead. + RTP_LLM_CHECK(params.num_copies >= 0 && params.num_copies <= MAX_FUSED_STRIDED_COPIES); + sycl::queue& queue = c10::xpu::getCurrentXPUStream(); + for (int i = 0; i < params.num_copies; ++i) { + RTP_LLM_CHECK(params.dst[i] != nullptr && params.src[i] != nullptr); + if (params.num_rows[i] == 0 || params.row_bytes[i] == 0) continue; + const char* src_base = static_cast(params.src[i]); + char* dst_base = static_cast(params.dst[i]); + if (params.src_row_stride[i] == params.row_bytes[i] + && params.dst_row_stride[i] == params.row_bytes[i]) { + // Contiguous: single memcpy for all rows + queue.memcpy(dst_base, src_base, params.row_bytes[i] * params.num_rows[i]); + } else { + for (size_t row = 0; row < params.num_rows[i]; ++row) { + queue.memcpy( + dst_base + row * params.dst_row_stride[i], + src_base + row * params.src_row_stride[i], + params.row_bytes[i]); + } + } + } #else throw std::runtime_error("No supported GPU backend found for fusedStridedCopy"); - return; #endif - invokeFusedStridedCopy(params, stream); } } // namespace rtp_llm diff --git a/rtp_llm/models_py/bindings/common/kernels/BUILD b/rtp_llm/models_py/bindings/common/kernels/BUILD index 1c354b2c8b..8063cf9c4a 100644 --- a/rtp_llm/models_py/bindings/common/kernels/BUILD +++ b/rtp_llm/models_py/bindings/common/kernels/BUILD @@ -226,9 +226,10 @@ cc_library( cc_library( name = "fuse_copy_kernel", - srcs = [ - "fuse_copy_kernel.cu", - ], + srcs = select({ + "//:using_xpu": [], + "//conditions:default": ["fuse_copy_kernel.cu"], + }), hdrs = [ "fuse_copy_kernel.h", ], diff --git a/rtp_llm/models_py/bindings/core/BUILD b/rtp_llm/models_py/bindings/core/BUILD index 65ce847bd2..4b87d4b665 100644 --- a/rtp_llm/models_py/bindings/core/BUILD +++ b/rtp_llm/models_py/bindings/core/BUILD @@ -26,6 +26,7 @@ cc_library( "@//:using_rocm": ["@local_config_rocm//rocm:rocm_headers", "@local_config_rocm//rocm:rocm", "//rtp_llm/models_py/bindings/rocm:rocm_types_hdr"], + "@//:using_xpu": [], "//conditions:default": [], }), copts = copts(), @@ -92,6 +93,7 @@ cc_library( "//rtp_llm/models_py/bindings/common/kernels:fuse_copy_util", ] + torch_deps() + select({ "@//:using_rocm": ["@local_config_rocm//rocm:rocm_headers"], + "@//:using_xpu": [], "//conditions:default": [], }), copts = copts(), @@ -135,11 +137,14 @@ cc_library( "//rtp_llm/cpp/utils:core_utils", "//rtp_llm/cpp/pybind:th_utils", "//rtp_llm/cpp/disaggregate/cache_store:cache_store_interface", - "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", "@havenask//aios/autil:stack_tracer", "@havenask//aios/autil:string_helper", "@havenask//aios/autil:scope", - ] + torch_deps(), + ] + torch_deps() + select({ + "@//:using_cuda": ["//rtp_llm/models_py/bindings/common/kernels:kernels_sampling"], + "@//:using_rocm": ["//rtp_llm/models_py/bindings/common/kernels:kernels_sampling"], + "//conditions:default": [], + }), copts = copts(), visibility = ["//visibility:public"], alwayslink = 1, @@ -211,20 +216,26 @@ cc_library( "//rtp_llm/cpp/utils:core_utils", "//rtp_llm/cpp/pybind:th_utils", "//rtp_llm/cpp/disaggregate/cache_store:cache_store_interface", - "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", "@havenask//aios/autil:stack_tracer", "@havenask//aios/autil:string_helper", "@havenask//aios/autil:scope", ] + torch_deps() + select({ + "@//:using_cuda": [ + "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", + "//rtp_llm/models_py/bindings/cuda/kernels/sampling:sampling", + ], "@//:using_rocm": [ + "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", "//rtp_llm/models_py/bindings/rocm/kernels/sampling:sampling", "//rtp_llm/models_py/bindings/rocm:rocm_host_utils", "@local_config_rocm//rocm:rocm_headers", "@local_config_rocm//rocm:rocm", ], - "@//:using_cuda": [ - "//rtp_llm/models_py/bindings/cuda/kernels/sampling:sampling", - ], + "@//:using_xpu": [], + "//conditions:default": [], + }), + features = select({ + "@//:using_xpu": ["xpu_sycl_compile"], "//conditions:default": [], }), copts = copts(), @@ -234,11 +245,24 @@ cc_library( cc_library( name = "exec_ctx_ops", - srcs = [ - "CudaOps.cc", - "CudaSampleOp.cc", - "CudaBeamSearchOp.cc", - ], + srcs = select({ + "@//:using_cuda": [ + "CudaOps.cc", + "CudaSampleOp.cc", + "CudaBeamSearchOp.cc", + ], + "@//:using_rocm": [ + "CudaOps.cc", + "CudaSampleOp.cc", + "CudaBeamSearchOp.cc", + ], + "@//:using_xpu": [ + "CudaOps.cc", + "CudaSampleOp.cc", + "CudaBeamSearchOp.cc", + ], + "//conditions:default": [], + }), deps = [ ":exec_ops_hdr", ":device_data", @@ -259,12 +283,17 @@ cc_library( "//rtp_llm/cpp/utils:core_utils", "//rtp_llm/cpp/pybind:th_utils", "//rtp_llm/cpp/disaggregate/cache_store:cache_store_interface", - "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", "@havenask//aios/autil:stack_tracer", "@havenask//aios/autil:string_helper", "@havenask//aios/autil:scope", ] + torch_deps() + select({ + "@//:using_cuda": [ + "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", + "//rtp_llm/models_py/bindings/cuda/kernels/sampling:sampling", + "//rtp_llm/models_py/bindings/cuda/kernels:kernels_speculative_sampling", + ], "@//:using_rocm": [ + "//rtp_llm/models_py/bindings/common/kernels:kernels_sampling", "//rtp_llm/models_py/bindings/rocm/kernels/sampling:sampling", "//rtp_llm/models_py/bindings/rocm:speculative_sampling", "//rtp_llm/models_py/bindings/rocm:rocm_host_utils", @@ -273,10 +302,11 @@ cc_library( "@local_config_rocm//rocm:rocm_headers", "@local_config_rocm//rocm:rocm", ], - "@//:using_cuda": [ - "//rtp_llm/models_py/bindings/cuda/kernels/sampling:sampling", - "//rtp_llm/models_py/bindings/cuda/kernels:kernels_speculative_sampling", - ], + "@//:using_xpu": [], + "//conditions:default": [], + }), + features = select({ + "@//:using_xpu": ["xpu_sycl_compile"], "//conditions:default": [], }), copts = copts(), diff --git a/rtp_llm/models_py/bindings/core/CudaBeamSearchOp.cc b/rtp_llm/models_py/bindings/core/CudaBeamSearchOp.cc index 1b9ede2a56..cb73b6171f 100644 --- a/rtp_llm/models_py/bindings/core/CudaBeamSearchOp.cc +++ b/rtp_llm/models_py/bindings/core/CudaBeamSearchOp.cc @@ -149,6 +149,101 @@ BeamSearchOutput sampleBeamSearch(BeamSearchParams params) { #undef DISPATCH_BOOL } +#elif USING_XPU // XPU: PyTorch fallback (no TRT kernel) + +// Basic beam search implementation using PyTorch ops. +// This is functionally correct but less optimized than the CUDA TensorRT-LLM kernel. +// It handles the core beam search algorithm: +// 1. Compute log-softmax probabilities +// 2. For each beam, find top-k candidates (k = beam_width_out) +// 3. Select the top beam_width_out beams globally across all candidates +// 4. Reconstruct token_ids, beam_indices, and cumulative log probs +BeamSearchOutput sampleBeamSearch(BeamSearchParams params) { + const int batch_size = params.logits.size(0); + const int beam_width_in = params.logits.size(1); + const int beam_width_out = params.num_beams_out != 0 + ? static_cast(params.num_beams_out) + : beam_width_in; + const int vocab_size = params.logits.size(2); + const int max_seq_len = params.token_ids.size(2); + + // Device for output tensors — use the same device as logits + auto device = params.logits.device(); + auto opts_int = torch::TensorOptions().dtype(torch::kInt32).device(device); + + // 1. Compute log-softmax probabilities: [batch, beam_in, vocab] + // Shape / dtype guards + RTP_LLM_CHECK_WITH_INFO(params.logits.dim() == 3, + "beam_search: logits must be 3D [batch, beam_in, vocab], got dim=" + + std::to_string(params.logits.dim())); + RTP_LLM_CHECK_WITH_INFO(params.cum_log_probs.dim() == 2, + "beam_search: cum_log_probs must be 2D [batch, beam_in], got dim=" + + std::to_string(params.cum_log_probs.dim())); + RTP_LLM_CHECK_WITH_INFO(beam_width_out > 0 && beam_width_out <= beam_width_in * vocab_size, + "beam_search: beam_width_out=" + std::to_string(beam_width_out) + + " out of valid range [1, beam_in*vocab=" + + std::to_string((int64_t)beam_width_in * vocab_size) + "]"); + + auto log_probs = params.logits.to(torch::kFloat32).log_softmax(-1); + + // 2. Add cumulative log probs from previous steps: [batch, beam_in, 1] + auto cum_log_probs_in = params.cum_log_probs.to(device).to(torch::kFloat32); + log_probs = log_probs + cum_log_probs_in.unsqueeze(-1); + + // 3. Flatten beams and vocab: [batch, beam_in * vocab] + auto flat_log_probs = log_probs.reshape({batch_size, beam_width_in * vocab_size}); + + // 4. Select top beam_width_out candidates per batch: [batch, beam_width_out] + auto topk_result = flat_log_probs.topk(beam_width_out, /*dim=*/-1, /*largest=*/true, /*sorted=*/true); + auto topk_log_probs = std::get<0>(topk_result); // [batch, beam_width_out] + auto topk_indices = std::get<1>(topk_result); // [batch, beam_width_out] + + // 5. Decode beam indices and token ids from flattened indices + auto beam_indices_out = (topk_indices / vocab_size).to(torch::kInt32); // which beam + auto output_ids = (topk_indices % vocab_size).to(torch::kInt32); // which token + + // 6. Build output token_ids by gathering from input token_ids + // For each (batch, out_beam), copy the history from the source beam + auto token_ids_in = params.token_ids.to(device); // [batch, beam_in, max_seq_len] + auto token_ids_out = torch::empty({batch_size, beam_width_out, max_seq_len}, opts_int); + + // Gather source beams: expand beam_indices to index into token_ids_in + auto beam_idx_expanded = beam_indices_out.to(torch::kLong) + .unsqueeze(-1) + .expand({batch_size, beam_width_out, max_seq_len}); + token_ids_out = token_ids_in.gather(1, beam_idx_expanded); + + // 7. Build output sequence_lengths and input_lengths from source beams + auto seq_lens_in = params.sequence_lengths.to(device); // [batch, beam_in] + auto input_lens_in = params.input_lengths.to(device); // [batch, beam_in] + auto beam_idx_1d = beam_indices_out.to(torch::kLong); // [batch, beam_width_out] + auto sequence_lengths_out = seq_lens_in.gather(1, beam_idx_1d); + auto input_lengths_out = input_lens_in.gather(1, beam_idx_1d); + + // 8. Write newly selected tokens at the current step position + // (mirroring what the CUDA populateTokenIds kernel does) + auto write_pos = sequence_lengths_out.to(torch::kLong).unsqueeze(-1); // [batch, beam_out, 1] + // Guard against scattering past the allocated sequence dimension. + // Use device-side masking throughout to avoid per-step host sync. + auto safe_mask = (write_pos < max_seq_len).squeeze(-1); // [batch, beam_out] + write_pos = write_pos.clamp(0, max_seq_len - 1); + // Write tokens only for beams that have not overflowed (device-side where). + auto safe_ids = output_ids.where(safe_mask, token_ids_out.gather(2, write_pos).squeeze(-1)); + token_ids_out.scatter_(2, write_pos, safe_ids.unsqueeze(-1)); + + // 9. Increment sequence lengths only for beams that have not overflowed. + sequence_lengths_out = sequence_lengths_out + safe_mask.to(torch::kInt32); + + // 10. Cumulative log probs + auto cum_log_probs_out = topk_log_probs.to(torch::kFloat32); + + return BeamSearchOutput({std::move(token_ids_out), + std::move(input_lengths_out), + std::move(sequence_lengths_out), + std::move(cum_log_probs_out), + std::move(beam_indices_out)}); +} + #else // Any other devices BeamSearchOutput sampleBeamSearch(BeamSearchParams params) { diff --git a/rtp_llm/models_py/bindings/core/CudaOps.cc b/rtp_llm/models_py/bindings/core/CudaOps.cc index 73330c4a88..647c6c5504 100644 --- a/rtp_llm/models_py/bindings/core/CudaOps.cc +++ b/rtp_llm/models_py/bindings/core/CudaOps.cc @@ -21,6 +21,8 @@ #include "rtp_llm/models_py/bindings/common/kernels/batch_copy.h" #include "rtp_llm/models_py/bindings/common/kernels/copy_utils.h" #include "rtp_llm/models_py/bindings/rocm/hip_host_utils.h" +#elif USING_XPU +#include #endif using namespace std; @@ -153,7 +155,90 @@ void runtimeMaskLogits(torch::Tensor& logits, const torch::Tensor& mask) { } } -#else // ROCm / non-CUDA +#elif USING_XPU + +// ============================================================ +// Copy ops (XPU) +// ============================================================ + +void runtimeCopy(const CopyParams& params) { + params.check(); + const auto& src = params.src; + const auto& dst = params.dst; + if (src.data_ptr() == dst.data_ptr()) { + return; + } + dst.copy_(src, /*non_blocking=*/src.is_xpu() && dst.is_xpu()); +} + +void multiMergeCopy(const MultiMergeCopyParams& params) { + RTP_LLM_CHECK_WITH_INFO(params.dst_ptr != nullptr, "multiMergeCopy: dst_ptr is null"); + RTP_LLM_CHECK_WITH_INFO(params.src_ptrs.size() == params.copy_size.size() + && params.src_ptrs.size() == params.dst_offsets.size(), + "multiMergeCopy: src_ptrs/copy_size/dst_offsets length mismatch"); + sycl::queue& queue = c10::xpu::getCurrentXPUStream(); + for (size_t i = 0; i < params.src_ptrs.size(); i++) { + if (params.copy_size[i] == 0) continue; + RTP_LLM_CHECK_WITH_INFO(params.src_ptrs[i] != nullptr, + "multiMergeCopy: src_ptrs[%zu] is null for non-zero copy", i); + auto dst = static_cast(params.dst_ptr) + params.dst_offsets[i]; + queue.memcpy(dst, params.src_ptrs[i], params.copy_size[i]); + } + // Rely on same-queue ordering; callers that need host-visible + // results must synchronize at a higher level. +} + +static void batchCopyFallback(const BatchCopyParams& params) { + auto gpu_device = getTorchDevice(); + for (uint32_t copy_type_enum = 0; copy_type_enum < BatchCopyParams::TYPE_SIZE; ++copy_type_enum) { + auto copy_type = BatchCopyParams::CopyType(copy_type_enum); + auto& buffers = params.copy_buffers[copy_type]; + size_t copy_batch_size = buffers.sizes.size(); + if (copy_batch_size == 0) + continue; + + for (size_t i = 0; i < copy_batch_size; ++i) { + size_t bytes = buffers.sizes[i]; + torch::Device dst_device = torch::kCPU, src_device = torch::kCPU; + switch (copy_type) { + case BatchCopyParams::D2D: + dst_device = gpu_device; + src_device = gpu_device; + break; + case BatchCopyParams::D2H: + dst_device = torch::kCPU; + src_device = gpu_device; + break; + case BatchCopyParams::H2D: + dst_device = gpu_device; + src_device = torch::kCPU; + break; + case BatchCopyParams::H2H: + break; + default: + RTP_LLM_FAIL("Unexpected CopyType %d", copy_type); + break; + } + auto dst_tensor = + torch::from_blob(buffers.dst_ptr[i], {(int64_t)bytes}, torch::dtype(torch::kUInt8).device(dst_device)); + auto src_tensor = torch::from_blob(const_cast(buffers.src_ptr[i]), + {(int64_t)bytes}, + torch::dtype(torch::kUInt8).device(src_device)); + runtimeCopy({dst_tensor, src_tensor, params.overlapped}); + } + } +} + +void runtimeMaskLogits(torch::Tensor& logits, const torch::Tensor& mask) { + // XPU fallback: mask semantics match CUDA kernel — mask==1 means BLOCKED. + TORCH_CHECK(mask.sizes() == logits.sizes(), + "runtimeMaskLogits: mask shape ", mask.sizes(), + " must match logits shape ", logits.sizes()); + auto bool_mask = mask.to(torch::kBool); + logits.masked_fill_(bool_mask, -std::numeric_limits::infinity()); +} + +#else // ROCm namespace { at::hip::HIPStream& getOverlapStream() { diff --git a/rtp_llm/models_py/bindings/core/CudaSampleOp.cc b/rtp_llm/models_py/bindings/core/CudaSampleOp.cc index 96cae37b63..a5d2c3bb7b 100644 --- a/rtp_llm/models_py/bindings/core/CudaSampleOp.cc +++ b/rtp_llm/models_py/bindings/core/CudaSampleOp.cc @@ -1,5 +1,7 @@ #include "rtp_llm/models_py/bindings/core/OpData.h" #include "rtp_llm/models_py/bindings/core/CommonDefines.h" +#include "rtp_llm/models_py/bindings/core/ExecOps.h" +#include #include @@ -396,7 +398,339 @@ void rejectionSampling(const RejectionSamplingParams& params) { stream)); } -#else // !USING_CUDA — ROCm platform +#elif USING_XPU // XPU platform — pure PyTorch sampling + +GreedyOutput sampleGreedy(const GreedyParams& params) { + const auto batch_size = params.logits.size(0); + const auto vocab_size_padded = params.logits.size(1); + const auto step = params.step; + auto device = getTorchDevice(); // returns torch::kXPU + + // Verify sampling parameters are on CPU (constructed by SamplerInputGatherer) + RTP_LLM_CHECK(params.temperature.is_cpu()); + RTP_LLM_CHECK(params.top_k.is_cpu()); + RTP_LLM_CHECK(params.top_p.is_cpu()); + + // [batch_size, step + 1] -> GPU + auto device_tokens = params.token_ids.to(device); + auto transposed_tokens = device_tokens.transpose(0, 1).contiguous(); + + // 0. Unsupported feature guard + if (params.no_repeat_ngram_size.has_value()) { + const auto& nrn = params.no_repeat_ngram_size.value(); + if (std::any_of(nrn.data_ptr(), + nrn.data_ptr() + batch_size, + [](int32_t s) { return s != 0; })) { + RTP_LLM_CHECK_WITH_INFO(false, + "no_repeat_ngram_size is not yet supported on XPU. " + "Set no_repeat_ngram_size=0 when running on Intel GPU."); + } + } + + // 0.5 do_sample: match CUDA semantics — save raw logits for + // do_sample=false rows so they can be restored after penalties, + // giving those rows argmax on unmodified logits. + torch::Tensor saved_logits; + if (params.do_sample.has_value()) { + auto top_k_ptr = params.top_k.data_ptr(); + bool any_greedy = false; + for (int64_t b = 0; b < batch_size; b++) { + if (!params.do_sample.value().data_ptr()[b]) { + top_k_ptr[b] = 1; + any_greedy = true; + } + } + if (any_greedy) { + saved_logits = params.logits.clone(); + } + } + + // 1. Temperature + if (std::any_of(params.temperature.data_ptr(), + params.temperature.data_ptr() + batch_size, + [](float t) { return t != 1.0f; })) { + for (int64_t b = 0; b < batch_size; b++) { + float t = params.temperature.data_ptr()[b]; + if (t != 1.0f && t > 0.0f) { + params.logits[b].div_(t); + } + } + } + + // 1.5 Force greedy on per-row temperature==0 in mixed batches. + // The all-zero temperature fast path below is skipped when only some rows + // are 0, so mark those rows top_k=1 to make the per-row top_k filter pick + // the argmax token deterministically (instead of softmax/multinomial). + { + auto top_k_force = reinterpret_cast(params.top_k.data_ptr()); + for (int64_t b = 0; b < batch_size; b++) { + if (params.temperature.data_ptr()[b] == 0.0f) { + top_k_force[b] = 1; + } + } + } + + // 2. Repetition / presence / frequency penalty + // Uses vectorized PyTorch ops to avoid slow element-wise CPU access on device tensors. + if (params.repetition_penalty.has_value()) { + TORCH_CHECK(params.presence_penalty.has_value() && params.frequency_penalty.has_value(), + "XPU sampling: repetition_penalty is set but presence_penalty and/or " + "frequency_penalty are missing. All three must be provided together."); + const auto& rep_pen = params.repetition_penalty.value(); + const auto& pres_pen = params.presence_penalty.value(); + const auto& freq_pen = params.frequency_penalty.value(); + // These tensors, along with sequence_lengths/input_lengths, are dereferenced on + // the host via data_ptr below; ensure they all live on CPU before reading them. + RTP_LLM_CHECK(rep_pen.is_cpu() && pres_pen.is_cpu() && freq_pen.is_cpu()); + RTP_LLM_CHECK(params.sequence_lengths.is_cpu() && params.input_lengths.is_cpu()); + for (int64_t b = 0; b < batch_size; b++) { + float rp = rep_pen.data_ptr()[b]; + float pp = pres_pen.data_ptr()[b]; + float fp = freq_pen.data_ptr()[b]; + if (rp == 1.0f && pp == 0.0f && fp == 0.0f) continue; + auto row = params.logits[b]; + // Use per-row actual length: decode rows use sequence_lengths, + // context rows use input_lengths, to avoid reading padding tokens. + const auto decoder_batch_size = params.sequence_lengths.size(0); + int actual_len; + if (b < decoder_batch_size) { + actual_len = params.sequence_lengths.data_ptr()[b]; + } else { + actual_len = params.input_lengths.data_ptr()[b]; + } + actual_len = std::min(actual_len, (int)step); + if (actual_len <= 0) continue; + auto past_tokens = transposed_tokens.slice(0, 0, actual_len).select(1, b); + + // Build frequency histogram on-device: freq_count[token_id] = count + // This replaces the O(step * unique_tokens) CPU-side nested loop. + auto freq_count = torch::zeros({vocab_size_padded}, + past_tokens.options().dtype(torch::kFloat)); + freq_count.scatter_add_(0, past_tokens.to(torch::kLong), + torch::ones({past_tokens.size(0)}, + torch::TensorOptions().dtype(torch::kFloat) + .device(past_tokens.device()))); + auto appeared = freq_count > 0; // mask of tokens that appeared + + // Apply repetition penalty: score = score/rp if score>0, score*rp if score<0 + if (rp != 1.0f) { + auto pos_mask = (row > 0) & appeared; + auto neg_mask = (row < 0) & appeared; + // Divide positive scores by rp, multiply negative scores by rp + auto adjusted = torch::where(pos_mask, row / rp, + torch::where(neg_mask, row * rp, row)); + row.copy_(adjusted); + } + // Apply presence penalty: subtract pp for every appeared token + if (pp != 0.0f) { + row.sub_(pp * appeared.to(torch::kFloat)); + } + // Apply frequency penalty: subtract fp*count for every token + if (fp != 0.0f) { + row.sub_(fp * freq_count); + } + } + } + + // 2.5 Restore raw logits for do_sample=false rows (after penalties). + if (saved_logits.defined() && params.do_sample.has_value()) { + for (int64_t b = 0; b < batch_size; b++) { + if (!params.do_sample.value().data_ptr()[b]) { + params.logits[b].copy_(saved_logits[b]); + } + } + saved_logits.reset(); + } + + // 2.6 Temperature==0 fast path (greedy argmax) + // When temperature is 0, the intent is greedy decoding. + // Skip the expensive softmax→multinomial path and use argmax directly. + if (std::all_of(params.temperature.data_ptr(), + params.temperature.data_ptr() + batch_size, + [](float t) { return t == 0.0f; }) + && !params.output_all_probs.has_value()) { + auto samples_t = transposed_tokens.slice(0, step, step + 1).squeeze(0); + auto selected = torch::argmax(params.logits, -1, false); + samples_t.copy_(selected); + if (params.cum_log_probs.has_value()) { + auto probs = torch::softmax(params.logits, -1); + auto token_prob = probs.gather(1, selected.unsqueeze(-1).to(torch::kLong)).squeeze(1); + auto cum_log_probs_t = params.cum_log_probs.value(); + cum_log_probs_t.add_(token_prob.log().to(cum_log_probs_t.device())); + } + params.token_ids.copy_(transposed_tokens.transpose(0, 1).contiguous()); + return GreedyOutput{}; + } + + // 3. Top-k=1 fast path (greedy argmax) + auto top_k_ptr = reinterpret_cast(params.top_k.data_ptr()); + if (std::all_of(top_k_ptr, top_k_ptr + batch_size, [](uint32_t t) { return t == 1; }) + && !params.output_all_probs.has_value()) { + auto samples_t = transposed_tokens.slice(0, step, step + 1).squeeze(0); + auto selected = torch::argmax(params.logits, -1, false); + samples_t.copy_(selected); + if (params.cum_log_probs.has_value()) { + auto probs = torch::softmax(params.logits, -1); + auto token_prob = probs.gather(1, selected.unsqueeze(-1).to(torch::kLong)).squeeze(1); + auto cum_log_probs_t = params.cum_log_probs.value(); + cum_log_probs_t.add_(token_prob.log().to(cum_log_probs_t.device())); + } + params.token_ids.copy_(transposed_tokens.transpose(0, 1).contiguous()); + return GreedyOutput{}; + } + + // 4. Softmax -> probabilities + auto probs_t = torch::softmax(params.logits, -1); + params.logits.copy_(probs_t); + + // 5. Apply top_k filtering + // Clone so in-place top_k/top_p filtering below does not mutate probs_t, + // which must remain the original (pre-filter) softmax source for + // return_original_all_probs and cum_log_probs. + auto filtered_probs = probs_t.clone(); + bool has_top_k = !std::all_of(top_k_ptr, top_k_ptr + batch_size, [](uint32_t t) { return t <= 0; }); + if (has_top_k) { + for (int64_t b = 0; b < batch_size; b++) { + int64_t k = top_k_ptr[b] <= 0 ? vocab_size_padded : (int64_t)top_k_ptr[b]; + // Clamp k into [1, vocab_size_padded] so an out-of-range top_k can + // never trigger an out-of-bounds topk() call. + if (k < 1) k = 1; + if (k > vocab_size_padded) k = vocab_size_padded; + if (k < vocab_size_padded) { + auto row = filtered_probs[b]; + auto [topk_vals, topk_inds] = row.topk(k); + // Zero the row and scatter back only the top-K values. + // This guarantees exactly K candidates survive even when + // multiple tokens share the same probability as the K-th. + row.zero_(); + row.scatter_(0, topk_inds, topk_vals); + } + } + } + + // 6. Apply top_p filtering + // Operate on a private copy: params.top_p is conceptually an input and may be + // reused by the caller, but the std::transform below rewrites it in place. + auto top_p_host = params.top_p.clone(); + auto top_p_ptr = top_p_host.data_ptr(); + std::transform(top_p_ptr, top_p_ptr + batch_size, top_p_ptr, [](float t) { return std::abs(t) < 1e-7f ? 1.0f : t; }); + bool has_top_p = !std::all_of(top_p_ptr, top_p_ptr + batch_size, [](float t) { return std::abs(t - 1.0f) < 1e-7f; }); + if (has_top_p) { + for (int64_t b = 0; b < batch_size; b++) { + float p = top_p_ptr[b]; + if (std::abs(p - 1.0f) >= 1e-7f) { + auto row = filtered_probs[b]; + auto [sorted_probs, sorted_indices] = row.sort(/*dim=*/0, /*descending=*/true); + auto cumsum = sorted_probs.cumsum(0); + auto mask = cumsum - sorted_probs > p; + sorted_probs.masked_fill_(mask, 0.0f); + row.scatter_(0, sorted_indices, sorted_probs); + } + } + } + + // 7. Re-normalize and sample + auto row_sums = filtered_probs.sum(-1, true); + // Guard against invalid probability distributions (all-zero / NaN / Inf rows). + // Fall back to argmax on the original logits for any degenerate row. + auto row_valid = (row_sums.squeeze(-1) > 0) & row_sums.squeeze(-1).isfinite(); + filtered_probs = filtered_probs / row_sums.clamp_min(1e-10f); + // Fix degenerate rows BEFORE multinomial to prevent crash on XPU. + // Replace invalid rows with a uniform distribution so multinomial won't throw. + // Done purely on-device (torch::where) to avoid any per-row D2H .item() syncs. + float uniform_val = 1.0f / static_cast(filtered_probs.size(1)); + filtered_probs = torch::where(row_valid.unsqueeze(-1), + filtered_probs, + torch::full_like(filtered_probs, uniform_val)); + auto selected = torch::multinomial(filtered_probs, 1, false).squeeze(-1); + // For any degenerate row, override the (uniform) draw with argmax on the + // original logits. Pure-device select, no host sync. + auto fallback = torch::argmax(params.logits, -1, false); + selected = torch::where(row_valid, selected, fallback); + + // Use per-request generators when available (respects request-level random seeds). + // Skip the D2H transfer entirely when no generators are defined — the common + // case in greedy/top-k sampling where no per-request seed is set. + bool has_any_generator = std::any_of( + params.generator.begin(), params.generator.end(), + [](const c10::optional& g) { return g.has_value() && g->defined(); }); + if (has_any_generator) { + // Copy row_valid to host ONCE so the loop incurs no per-row D2H syncs, + // and skip degenerate rows so the argmax fallback is preserved. + auto row_valid_cpu = row_valid.to(torch::kCPU); + auto* row_valid_host = row_valid_cpu.data_ptr(); + for (int64_t b = 0; b < batch_size; b++) { + if (params.generator[b].defined() && row_valid_host[b]) { + // selected[b] = ... does NOT write back in-place in C++ libtorch; + // use select(0,b).copy_() to update the underlying storage. + auto sampled = torch::multinomial( + filtered_probs[b].unsqueeze(0), 1, false, params.generator[b]).squeeze(); + selected.select(0, b).copy_(sampled); + } + } + } + + auto samples_t = transposed_tokens.slice(0, step, step + 1).squeeze(0); + samples_t.copy_(selected); + + bool need_output_all_probs = params.output_all_probs.has_value(); + if (need_output_all_probs) { + if (params.return_original_all_probs) { + // Write pre-filter softmax probabilities (before top_k/top_p filtering) + params.output_all_probs.value().copy_(probs_t); + } else { + params.output_all_probs.value().copy_(filtered_probs); + } + } + + // 8. Update cum_log_probs + if (params.cum_log_probs.has_value()) { + // Use the same probability source as output_all_probs for consistency + auto& prob_source = (params.return_original_all_probs) ? probs_t : filtered_probs; + auto token_prob = prob_source.gather(1, selected.unsqueeze(-1).to(torch::kLong)).squeeze(1); + auto log_prob = token_prob.log(); + // Degenerate rows (row_valid=false) emitted the argmax fallback token; + // their prob source may be 0/NaN, so log_prob is -inf/NaN. Zero those + // updates so a single invalid row cannot corrupt cum_log_probs (which + // would cascade into beam ranking / stop criteria). + log_prob = torch::where(row_valid, log_prob, torch::zeros_like(log_prob)); + auto cum_log_probs_t = params.cum_log_probs.value(); + cum_log_probs_t.add_(log_prob.to(cum_log_probs_t.device())); + } + + // 9. Copy back + params.token_ids.copy_(transposed_tokens.transpose(0, 1).contiguous()); + // Signal degenerate rows (invalid prob distribution: all-zero / NaN / Inf) + // to the caller via success=false instead of silently trusting the argmax + // fallback. This matches the CUDA/flashinfer contract (the dispatcher turns + // a false row into a reported error). The uniform/argmax fallback above only + // exists to keep multinomial from crashing on XPU; rows remain marked failed. + return GreedyOutput{row_valid}; +} + +// XPU: Speculative (draft-model) sampling is not supported. +// This requires chain_speculative_sampling kernel which performs rejection sampling +// between draft and target model probabilities. A pure PyTorch implementation would +// need: (1) compute acceptance probability min(1, target_prob/draft_prob), +// (2) accept/reject each drafted token, (3) resample rejected positions. +// TODO(xpu): Implement PyTorch fallback when speculative decoding is needed on XPU. +void chainSpeculativeSampling(const SpeculativeSamplingParams& params) { + RTP_LLM_CHECK_WITH_INFO(false, + "Speculative sampling is not supported on XPU. " + "Disable speculative decoding (draft model) when running on Intel GPU."); +} + +// XPU: Rejection sampling (speculative-decode accept/reject) is not supported. +// Same rationale as chainSpeculativeSampling above — requires the rejection +// sampling kernel or a PyTorch fallback. Throw a clear error instead of +// silently emitting wrong tokens. +void rejectionSampling(const RejectionSamplingParams& params) { + RTP_LLM_CHECK_WITH_INFO(false, + "Rejection sampling is not supported on XPU. " + "Disable speculative decoding (draft model) when running on Intel GPU."); +} + +#else // ROCm platform (fallback) } // namespace rtp_llm — temporarily close for includes @@ -682,6 +1016,6 @@ void rejectionSampling(const RejectionSamplingParams& params) { RTP_LLM_CHECK_WITH_INFO(err == hipSuccess, "invokeRejectionSampling failed: %s", hipGetErrorString(err)); } -#endif // USING_CUDA +#endif // USING_CUDA / USING_XPU / USING_ROCM } // namespace rtp_llm diff --git a/rtp_llm/models_py/bindings/core/ExecOps.cc b/rtp_llm/models_py/bindings/core/ExecOps.cc index 4ba2a154ce..6439df7fdf 100644 --- a/rtp_llm/models_py/bindings/core/ExecOps.cc +++ b/rtp_llm/models_py/bindings/core/ExecOps.cc @@ -20,6 +20,10 @@ #include #elif USING_ROCM #include +#elif USING_XPU +#include +#include +#include #endif #include @@ -27,6 +31,8 @@ using DeviceGuard = at::cuda::CUDAGuard; #elif USING_ROCM using DeviceGuard = c10::hip::HIPGuardMasqueradingAsCUDA; +#elif USING_XPU +using DeviceGuard = c10::DeviceGuard; #endif namespace rtp_llm { @@ -98,6 +104,14 @@ void runtimeSyncAndCheck() { check_cuda_error(); } +#elif USING_XPU + +void runtimeSyncAndCheck() { + // PyTorch XPU's synchronize() internally checks for SYCL async errors + // and throws on failure, so no separate error check is needed here. + c10::xpu::getCurrentXPUStream().synchronize(); +} + #else // ROCm void runtimeSyncAndCheck() { @@ -119,6 +133,14 @@ std::shared_ptr runtimeCreateEvent() { return event; } +#elif USING_XPU + +std::shared_ptr runtimeCreateEvent() { + auto event = std::make_shared(torch::kXPU); + event->record(c10::xpu::getCurrentXPUStream()); + return event; +} + #else // ROCm std::shared_ptr runtimeCreateEvent() { @@ -301,6 +323,14 @@ torch::Tensor preprocessGemmWeightByKey(const std::string& key, torch::Tensor we return weight; } +torch::Tensor preprocessWeightScale(torch::Tensor weight, torch::Tensor scale) { + return weight; +} +#elif USING_XPU +torch::Tensor preprocessGemmWeightByKey(const std::string& key, torch::Tensor weight, bool user_arm_gemm_use_kai) { + return weight; +} + torch::Tensor preprocessWeightScale(torch::Tensor weight, torch::Tensor scale) { return weight; } @@ -322,6 +352,11 @@ void cudaCheckLastError() { if (err != hipSuccess) { RTP_LLM_LOG_ERROR("ROCm error: %s", hipGetErrorString(err)); } +#elif USING_XPU + // XPU/SYCL: errors are reported either via synchronous exceptions at + // submit time or via the async error handler on queue.wait(). PyTorch's + // XPU runtime installs an async handler that throws on errors, so + // explicit error polling is unnecessary here. #endif } @@ -332,6 +367,8 @@ void cudaPreRun(int device_id) { at::cuda::setCurrentCUDAStream(at::cuda::getDefaultCUDAStream(device_id)); #elif USING_ROCM hipSetDevice(device_id); +#elif USING_XPU + c10::xpu::set_device(static_cast(device_id)); #endif } @@ -359,6 +396,46 @@ ExecStatus getGpuExecStatus() { RTP_LLM_CHECK(error == cudaSuccess); #elif USING_ROCM hipMemGetInfo(&mem.free_bytes, &total_bytes); +#elif USING_XPU + { + auto device_idx = static_cast(g_device_id); + auto* props = at::xpu::getDeviceProperties(device_idx); + RTP_LLM_CHECK_WITH_INFO(props != nullptr, "at::xpu::getDeviceProperties returned null for device " + std::to_string(device_idx)); + total_bytes = props->global_mem_size; + auto stats = c10::xpu::XPUCachingAllocator::getDeviceStats(device_idx); + size_t reserved = stats.reserved_bytes[static_cast(c10::CachingAllocator::StatType::AGGREGATE)].current; + size_t raw_free = (total_bytes > reserved) ? (total_bytes - reserved) : 0; + // Unlike cudaMemGetInfo, the XPU caching allocator only knows about memory + // this process reserved; it cannot observe memory held by the driver or by + // other processes/contexts on the same device. Withhold a conservative + // fraction of total memory so KV-cache sizing under-reports rather than + // over-allocating into space that is actually occupied externally. The + // ratio is overridable via XPU_MEM_RESERVE_RATIO (in [0, 1)); prefer + // setting kv_cache_mem_mb explicitly when exact control is required. + static const double reserve_ratio = []() { + double ratio = 0.10; + const char* env = std::getenv("XPU_MEM_RESERVE_RATIO"); + if (env != nullptr) { + char* endptr = nullptr; + double parsed = std::strtod(env, &endptr); + if (endptr != env && *endptr == '\0' && parsed >= 0.0 && parsed < 1.0) { + ratio = parsed; + } else { + RTP_LLM_LOG_WARNING("Invalid XPU_MEM_RESERVE_RATIO='%s', using default %.2f", + env, ratio); + } + } + return ratio; + }(); + size_t external_headroom = static_cast(total_bytes * reserve_ratio); + mem.free_bytes = (raw_free > external_headroom) ? (raw_free - external_headroom) : 0; + // NOTE: Do NOT set max_consumed_bytes here. The AGGREGATE peak from + // the caching allocator includes model-weight allocations that are + // already accounted for by the reduced available_bytes after warmup. + // Setting it would double-count weights and fail the + // "device_reserved > runtime_required" check in MemoryEvaluationHelper. + // Match the CUDA path which leaves max_consumed_bytes = 0. + } #endif mem.used_bytes = total_bytes - mem.free_bytes; mem.available_bytes = mem.free_bytes; @@ -367,10 +444,6 @@ ExecStatus getGpuExecStatus() { return status; } -torch::Device getTorchCudaDevice() { - return torch::Device(torch::kCUDA); -} - namespace { static bool g_trace_memory = false; } @@ -508,9 +581,9 @@ OverallExpertStats execCreateMoeExpertStates(const ExpertStatsParams& params) { states.log_exp_num = params.log_exp_num; states.phy_exp_num = params.phy_exp_num; states.stats_buf.log_stats_buf = torch::zeros({(int64_t)params.layer_num, (int64_t)params.log_exp_num}, - torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + torch::TensorOptions(torch::kInt32).device(getTorchDevice())); states.stats_buf.gpu_loads_buf = torch::zeros({(int64_t)params.layer_num, (int64_t)params.ep_size}, - torch::TensorOptions(torch::kInt32).device(torch::kCUDA)); + torch::TensorOptions(torch::kInt32).device(getTorchDevice())); return states; } @@ -556,6 +629,18 @@ MlaOpsType initRuntime(size_t device_id, bool trace_memory, bool enable_comm_ove #elif USING_ROCM RTP_LLM_LOG_INFO("Initialize runtime (ROCm). device_id=%zu", device_id); ROCM_CHECK(hipSetDevice(device_id)); +#elif USING_XPU + RTP_LLM_LOG_INFO("Initialize runtime (XPU/Intel GPU). device_id=%zu", device_id); + c10::xpu::set_device(static_cast(device_id)); + + if (resolved_mla_ops_type == MlaOpsType::AUTO) { + resolved_mla_ops_type = MlaOpsType::MHA; + } + if (resolved_mla_ops_type != MlaOpsType::MHA) { + RTP_LLM_LOG_WARNING("XPU does not support MLA ops type %d, falling back to MHA", + static_cast(resolved_mla_ops_type)); + resolved_mla_ops_type = MlaOpsType::MHA; + } #endif g_enable_comm_overlap = enable_comm_overlap; diff --git a/rtp_llm/models_py/bindings/core/ExecOps.h b/rtp_llm/models_py/bindings/core/ExecOps.h index 71aee7b0de..764a2a3d42 100644 --- a/rtp_llm/models_py/bindings/core/ExecOps.h +++ b/rtp_llm/models_py/bindings/core/ExecOps.h @@ -58,7 +58,26 @@ void cudaProfilerEnd(); // =================================================================== ExecStatus getGpuExecStatus(); -torch::Device getTorchCudaDevice(); + +inline torch::Device getTorchDevice() { +#if USING_XPU + return torch::Device(torch::kXPU, static_cast(getDeviceId())); +#elif USING_CUDA || USING_ROCM + return torch::Device(torch::kCUDA); +#else + return torch::Device(torch::kCPU); +#endif +} +inline torch::Device getTorchCudaDevice() { return getTorchDevice(); } + +inline torch::Tensor maybePinMemory(torch::Tensor t) { +#if !USING_XPU + return t.pin_memory(); +#else + return t; +#endif +} + void setTraceMemory(bool trace_memory); // =================================================================== diff --git a/rtp_llm/models_py/bindings/xpu/BUILD b/rtp_llm/models_py/bindings/xpu/BUILD new file mode 100644 index 0000000000..7a7e070f0d --- /dev/null +++ b/rtp_llm/models_py/bindings/xpu/BUILD @@ -0,0 +1,20 @@ +load("//:def.bzl", "copts") +load("@arch_config//:arch_select.bzl", "torch_deps") + +package(default_visibility=["//rtp_llm:__subpackages__"]) + +cc_library( + name = "xpu_bindings_register", + srcs = ["RegisterXpuOps.cc"], + hdrs = [ + "RegisterXpuBaseBindings.hpp", + "XpuTorchExt.h", + ], + copts = copts(), + deps = [ + "//rtp_llm/models_py/bindings:register_ops_hdr", + "//rtp_llm/models_py/bindings/common:common", + ] + torch_deps(), + visibility = ["//visibility:public"], + alwayslink = 1, +) diff --git a/rtp_llm/models_py/bindings/xpu/RegisterXpuBaseBindings.hpp b/rtp_llm/models_py/bindings/xpu/RegisterXpuBaseBindings.hpp new file mode 100644 index 0000000000..2d98841ba0 --- /dev/null +++ b/rtp_llm/models_py/bindings/xpu/RegisterXpuBaseBindings.hpp @@ -0,0 +1,643 @@ +#pragma once + +#include +#include +#include "rtp_llm/models_py/bindings/common/WriteCacheStoreOp.h" + +namespace py = pybind11; + +namespace torch_ext { + +// ── Helper: RMSNorm (pure PyTorch) ───────────────────────────────────────── +static void xpu_rmsnorm_impl(at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + double eps) { + auto float_input = input.to(at::kFloat); + auto variance = float_input.pow(2).mean(-1, /*keepdim=*/true); + auto normed = float_input * at::rsqrt(variance + eps); + output.copy_((weight * normed).to(input.scalar_type())); +} + +// ── Helper: LayerNorm (pure PyTorch) ──────────────────────────────────────── +static void xpu_layernorm_impl(at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + const at::Tensor& beta, + double eps) { + auto norm_shape = weight.sizes().vec(); + auto result = at::layer_norm(input, norm_shape, weight, beta, eps); + output.copy_(result); +} + +void registerBaseXpuBindings(py::module& rtp_ops_m) { + + // ── Debug ─────────────────────────────────────────────────────────────── + rtp_ops_m.def("debug_kernel", + [](const at::Tensor& /*data*/, + int64_t /*start_row*/, int64_t /*start_col*/, + int64_t /*m*/, int64_t /*n*/, + int64_t /*row_len*/, int64_t /*info_id*/) { + }, + "Debug kernel (no-op on XPU)", + py::arg("data"), + py::arg("start_row"), + py::arg("start_col"), + py::arg("m"), + py::arg("n"), + py::arg("row_len"), + py::arg("info_id")); + + // ── Write cache store ─────────────────────────────────────────────────── + // Delegates to the shared WriteCacheStoreOp implementation (same as CUDA/ROCm). + // This writes KV cache data to the cache store for prefix reuse. + rtp_ops_m.def("write_cache_store", + &rtp_llm::WriteCacheStoreOp, + "WriteCacheStoreOp kernel", + py::arg("input_lengths"), + py::arg("prefix_lengths"), + py::arg("kv_cache_block_id_host"), + py::arg("cache_store_member"), + py::arg("kv_cache")); + + // ── RMSNorm ───────────────────────────────────────────────────────────── + rtp_ops_m.def("rmsnorm", + [](at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + double eps, + int64_t /*cuda_stream*/) { + xpu_rmsnorm_impl(output, input, weight, eps); + }, + "RMSNorm kernel (PyTorch fallback on XPU)", + py::arg("output"), + py::arg("input"), + py::arg("weight"), + py::arg("eps"), + py::arg("cuda_stream") = 0); + + // ── Fused Add RMSNorm ─────────────────────────────────────────────────── + rtp_ops_m.def("fused_add_rmsnorm", + [](at::Tensor& input, + at::Tensor& residual, + const at::Tensor& weight, + double eps, + int64_t /*cuda_stream*/) { + input.add_(residual); + residual.copy_(input); + auto float_input = input.to(at::kFloat); + auto variance = float_input.pow(2).mean(-1, /*keepdim=*/true); + auto normed = float_input * at::rsqrt(variance + eps); + input.copy_((weight * normed).to(input.scalar_type())); + }, + "Fused Add RMSNorm kernel (PyTorch fallback on XPU)", + py::arg("input"), + py::arg("residual"), + py::arg("weight"), + py::arg("eps"), + py::arg("cuda_stream") = 0); + + // ── SiLU and Mul ──────────────────────────────────────────────────────── + rtp_ops_m.def("silu_and_mul", + [](at::Tensor& output, + const at::Tensor& input, + int64_t /*cuda_stream*/) { + TORCH_CHECK(input.size(-1) % 2 == 0, + "silu_and_mul: input last dim (", input.size(-1), + ") must be even (gate|up layout)."); + int64_t d = input.size(-1) / 2; + auto gate = input.narrow(-1, 0, d); + auto up = input.narrow(-1, d, d); + output.copy_(at::silu(gate) * up); + }, + "SiLU and Mul kernel (PyTorch fallback on XPU)", + py::arg("output"), + py::arg("input"), + py::arg("cuda_stream") = 0); + + // ── Fused QK RMSNorm ──────────────────────────────────────────────────── + rtp_ops_m.def("fused_qk_rmsnorm", + [](at::Tensor& IO, + const at::Tensor& q_gamma, + const at::Tensor& k_gamma, + double layernorm_eps, + int64_t q_group_num, + int64_t k_group_num, + int64_t m, + int64_t n, + int64_t norm_size) { + (void)n; // Unused in PyTorch fallback (from CUDA kernel signature) + int64_t q_size = q_group_num * norm_size; + int64_t k_size = k_group_num * norm_size; + auto q_flat = IO.narrow(0, 0, m).narrow(1, 0, q_size) + .reshape({m * q_group_num, norm_size}); + auto q_out = at::empty_like(q_flat); + xpu_rmsnorm_impl(q_out, q_flat, q_gamma, layernorm_eps); + IO.narrow(0, 0, m).narrow(1, 0, q_size).copy_( + q_out.reshape({m, q_size})); + auto k_flat = IO.narrow(0, 0, m).narrow(1, q_size, k_size) + .reshape({m * k_group_num, norm_size}); + auto k_out = at::empty_like(k_flat); + xpu_rmsnorm_impl(k_out, k_flat, k_gamma, layernorm_eps); + IO.narrow(0, 0, m).narrow(1, q_size, k_size).copy_( + k_out.reshape({m, k_size})); + }, + "Fused QK RMSNorm kernel (decomposed on XPU)", + py::arg("IO"), + py::arg("q_gamma"), + py::arg("k_gamma"), + py::arg("layernorm_eps"), + py::arg("q_group_num"), + py::arg("k_group_num"), + py::arg("m"), + py::arg("n"), + py::arg("norm_size")); + + // ── LayerNorm ─────────────────────────────────────────────────────────── + rtp_ops_m.def("layernorm", + [](at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + const at::Tensor& beta, + double eps) { + xpu_layernorm_impl(output, input, weight, beta, eps); + }, + "LayerNorm kernel (PyTorch fallback on XPU)", + py::arg("output"), + py::arg("input"), + py::arg("weight"), + py::arg("beta"), + py::arg("eps")); + + // ── Fused Add LayerNorm ───────────────────────────────────────────────── + rtp_ops_m.def("fused_add_layernorm", + [](at::Tensor& input, + at::Tensor& residual, + const at::Tensor& bias, + const at::Tensor& weight, + const at::Tensor& beta, + double eps) { + input.add_(residual); + if (bias.numel() > 0) { + input.add_(bias); + } + residual.copy_(input); + auto norm_shape = weight.sizes().vec(); + auto normed = at::layer_norm(input, norm_shape, weight, beta, eps); + input.copy_(normed); + }, + "Fused Add LayerNorm kernel (PyTorch fallback on XPU)", + py::arg("input"), + py::arg("residual"), + py::arg("bias"), + py::arg("weight"), + py::arg("beta"), + py::arg("eps")); + + // ── Per-token group quant int8 ────────────────────────────────────────── + rtp_ops_m.def("per_token_group_quant_int8", + [](const at::Tensor& input, + at::Tensor& output_q, + at::Tensor& output_s, + int64_t group_size, + double eps, + double int8_min, + double int8_max, + bool scale_ue8m0) { + TORCH_CHECK(!scale_ue8m0, "per_token_group_quant_int8: scale_ue8m0=true is not yet supported on XPU."); + TORCH_CHECK(group_size > 0, "per_token_group_quant_int8: group_size must be > 0, got ", group_size); + auto float_input = input.to(at::kFloat); + auto shape = float_input.sizes().vec(); + int64_t last_dim = shape.back(); + TORCH_CHECK(last_dim % group_size == 0, + "per_token_group_quant_int8: last_dim (", last_dim, + ") must be divisible by group_size (", group_size, ")"); + int64_t num_groups = last_dim / group_size; + auto reshaped = float_input.reshape({-1, num_groups, group_size}); + auto abs_max = reshaped.abs().amax(-1, true).clamp_min(eps); + auto scale = abs_max / int8_max; + auto quantized = (reshaped / scale).clamp(int8_min, int8_max).round().to(at::kChar); + output_q.copy_(quantized.reshape(shape).to(output_q.scalar_type())); + output_s.copy_(scale.squeeze(-1).to(output_s.scalar_type())); + }, + "Int8 per-token group quantization (PyTorch fallback on XPU)", + py::arg("input"), + py::arg("output_q"), + py::arg("output_s"), + py::arg("group_size"), + py::arg("eps"), + py::arg("int8_min"), + py::arg("int8_max"), + py::arg("scale_ue8m0")); + + // ── Per-token group quant fp8 ─────────────────────────────────────────── + rtp_ops_m.def("per_token_group_quant_fp8", + [](const at::Tensor& input, + at::Tensor& output_q, + at::Tensor& output_s, + int64_t group_size, + double eps, + double fp8_min, + double fp8_max, + bool scale_ue8m0) { + TORCH_CHECK(!scale_ue8m0, "per_token_group_quant_fp8: scale_ue8m0=true is not yet supported on XPU."); + TORCH_CHECK(group_size > 0, "per_token_group_quant_fp8: group_size must be > 0, got ", group_size); + auto float_input = input.to(at::kFloat); + auto shape = float_input.sizes().vec(); + int64_t last_dim = shape.back(); + TORCH_CHECK(last_dim % group_size == 0, + "per_token_group_quant_fp8: last_dim (", last_dim, + ") must be divisible by group_size (", group_size, ")"); + int64_t num_groups = last_dim / group_size; + auto reshaped = float_input.reshape({-1, num_groups, group_size}); + auto abs_max = reshaped.abs().amax(-1, true).clamp_min(eps); + auto scale = abs_max / fp8_max; + auto quantized = (reshaped / scale).clamp(fp8_min, fp8_max); + output_q.copy_(quantized.reshape(shape).to(output_q.scalar_type())); + output_s.copy_(scale.squeeze(-1).to(output_s.scalar_type())); + }, + "FP8 per-token group quantization (PyTorch fallback on XPU)", + py::arg("input"), + py::arg("output_q"), + py::arg("output_s"), + py::arg("group_size"), + py::arg("eps"), + py::arg("fp8_min"), + py::arg("fp8_max"), + py::arg("scale_ue8m0")); + + // ── Per-token group quant fp8 v2 ──────────────────────────────────────── + rtp_ops_m.def("per_token_group_quant_fp8_v2", + [](const at::Tensor& input, + at::Tensor& output_q, + at::Tensor& output_s, + int64_t group_size, + double eps, + double fp8_min, + double fp8_max, + bool scale_ue8m0, + bool fuse_silu_and_mul, + py::object masked_m_obj) { + // Accept both int and Tensor for masked_m to match CUDA API. + int64_t masked_m = 0; + if (!masked_m_obj.is_none()) { + if (py::isinstance(masked_m_obj)) { + masked_m = masked_m_obj.cast(); + } else { + auto t = py::cast(masked_m_obj); + if (t.numel() == 1) { + masked_m = t.item(); + } else if (t.numel() > 1) { + TORCH_CHECK(false, + "per_token_group_quant_fp8_v2: per-expert masked layout " + "(Tensor with numel > 1) is not yet supported on XPU. " + "Pass a scalar or int."); + } + } + } + at::Tensor actual_input; + if (fuse_silu_and_mul) { + TORCH_CHECK(input.size(-1) % 2 == 0, + "per_token_group_quant_fp8_v2: fuse_silu_and_mul requires " + "even last dim, got ", input.size(-1)); + int64_t d = input.size(-1) / 2; + auto gate = input.narrow(-1, 0, d); + auto up = input.narrow(-1, d, d); + actual_input = at::silu(gate) * up; + } else { + actual_input = input; + } + TORCH_CHECK(masked_m == 0 || masked_m == input.size(0), + "per_token_group_quant_fp8_v2: per-expert masked_m (masked_m=", + masked_m, ", input rows=", input.size(0), + ") is not yet supported on XPU. " + "masked_m must be 0 or equal to input.size(0)."); + TORCH_CHECK(!scale_ue8m0, "per_token_group_quant_fp8_v2: scale_ue8m0=true is not yet supported on XPU."); + TORCH_CHECK(group_size > 0, "per_token_group_quant_fp8_v2: group_size must be > 0, got ", group_size); + auto float_input = actual_input.to(at::kFloat); + auto shape = float_input.sizes().vec(); + int64_t last_dim = shape.back(); + TORCH_CHECK(last_dim % group_size == 0, + "per_token_group_quant_fp8_v2: last_dim (", last_dim, + ") must be divisible by group_size (", group_size, ")"); + int64_t num_groups = last_dim / group_size; + auto reshaped = float_input.reshape({-1, num_groups, group_size}); + auto abs_max = reshaped.abs().amax(-1, true).clamp_min(eps); + auto scale = abs_max / fp8_max; + auto quantized = (reshaped / scale).clamp(fp8_min, fp8_max); + auto q_view = quantized.reshape(shape).to(output_q.scalar_type()); + auto s_view = scale.squeeze(-1).to(output_s.scalar_type()); + output_q.copy_(q_view); + output_s.copy_(s_view); + }, + "FP8 per-token group quantization v2 (PyTorch fallback on XPU)", + py::arg("input"), + py::arg("output_q"), + py::arg("output_s"), + py::arg("group_size"), + py::arg("eps"), + py::arg("fp8_min"), + py::arg("fp8_max"), + py::arg("scale_ue8m0"), + py::arg("fuse_silu_and_mul"), + py::arg("masked_m")); + + // ── MoE TopK Softmax ──────────────────────────────────────────────────── + rtp_ops_m.def("moe_topk_softmax", + [](at::Tensor& topk_weights, + at::Tensor& topk_indices, + at::Tensor& token_expert_indices, + const at::Tensor& gating_output) { + int64_t k = topk_weights.size(-1); + // Shape guards: topk_indices is [num_tokens, k], token_expert_indices + // must be [num_tokens * k] to hold the flattened expert assignments. + TORCH_CHECK(topk_indices.dim() == 2 && topk_indices.size(-1) == k, + "XPU moe_softmax_topk: topk_indices must be [T, k], got ", + topk_indices.sizes()); + TORCH_CHECK(token_expert_indices.numel() == topk_indices.numel(), + "XPU moe_softmax_topk: token_expert_indices.numel()=", + token_expert_indices.numel(), " != topk_indices.numel()=", + topk_indices.numel()); + auto softmaxed = at::softmax(gating_output.to(at::kFloat), -1); + auto topk_result = softmaxed.topk(k, -1); + topk_weights.copy_(std::get<0>(topk_result).to(topk_weights.scalar_type())); + topk_indices.copy_(std::get<1>(topk_result).to(topk_indices.scalar_type())); + token_expert_indices.copy_(topk_indices.reshape({-1}).to(token_expert_indices.scalar_type())); + }, + "MoE TopK Softmax (PyTorch fallback on XPU)", + py::arg("topk_weights"), + py::arg("topk_indices"), + py::arg("token_expert_indices"), + py::arg("gating_output")); + + // ── Embedding ─────────────────────────────────────────────────────────── + rtp_ops_m.def("embedding", + [](at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + std::optional position_ids, + std::optional token_type_ids, + std::optional text_tokens_mask) { + // XPU plain embedding lookup; position/token-type inputs are + // unused (consumed by fused paths on other backends). + // text_tokens_mask is used in multimodal to blank non-text + // positions — silently ignoring it produces wrong outputs. + TORCH_CHECK(!position_ids.has_value() || position_ids->numel() == 0, + "XPU plain embedding ignores position_ids (the fused " + "positional path is not implemented). Use embedding_bert " + "for positional embeddings."); + TORCH_CHECK(!token_type_ids.has_value() || token_type_ids->numel() == 0, + "XPU plain embedding ignores token_type_ids. Use " + "embedding_bert for BERT token-type semantics."); + TORCH_CHECK(!text_tokens_mask.has_value() || text_tokens_mask->numel() == 0, + "XPU embedding does not yet support text_tokens_mask " + "(multimodal masked embedding). " + "Disable multimodal prefix on XPU or implement the mask."); + auto result = at::embedding(weight, input.to(at::kLong)); + output.copy_(result.to(output.scalar_type())); + }, + "Embedding lookup (PyTorch fallback on XPU)", + py::arg("output"), + py::arg("input"), + py::arg("weight"), + py::arg("position_ids") = std::nullopt, + py::arg("token_type_ids") = std::nullopt, + py::arg("text_tokens_mask") = std::nullopt); + + // ── Embedding BERT ────────────────────────────────────────────────────── + rtp_ops_m.def("embedding_bert", + [](at::Tensor& output, + const at::Tensor& input, + const at::Tensor& weight, + const at::Tensor& combo_position_ids, + const at::Tensor& position_encoding, + const at::Tensor& combo_tokens_type_ids, + const at::Tensor& token_type_embedding, + float input_embedding_scalar) { + auto word_emb = at::embedding(weight, input.to(at::kLong)); + auto pos_emb = at::embedding(position_encoding, combo_position_ids.to(at::kLong)); + auto type_emb = at::embedding(token_type_embedding, combo_tokens_type_ids.to(at::kLong)); + auto result = (word_emb * input_embedding_scalar + pos_emb + type_emb); + output.copy_(result.to(output.scalar_type())); + }, + "BERT Embedding lookup (PyTorch fallback on XPU)", + py::arg("output"), + py::arg("input"), + py::arg("weight"), + py::arg("combo_position_ids"), + py::arg("position_encoding"), + py::arg("combo_tokens_type_ids"), + py::arg("token_type_embedding"), + py::arg("input_embedding_scalar") = 1.0f); + + // ── Reuse KV cache indexed batched ────────────────────────────────────── + // MLA (Multi-head Latent Attention) is not supported on XPU. + // This op should never be called; fail loudly if it is. + rtp_ops_m.def("reuse_kv_cache_indexed_batched", + [](at::Tensor& /*final_compressed_kv*/, + at::Tensor& /*final_k_pe*/, + const at::Tensor& /*compressed_kv*/, + const at::Tensor& /*k_pe*/, + const at::Tensor& /*kv_cache_base*/, + const at::Tensor& /*reuse_cache_page_indice*/, + py::object /*batch_reuse_info_vec*/, + const at::Tensor& /*qo_indptr*/, + int64_t /*tokens_per_block*/) { + TORCH_CHECK(false, + "reuse_kv_cache_indexed_batched is not implemented on XPU. " + "MLA (Multi-head Latent Attention) is not supported."); + }, + "Reuse KV cache indexed batched (not implemented on XPU - MLA unsupported)", + py::arg("final_compressed_kv"), + py::arg("final_k_pe"), + py::arg("compressed_kv"), + py::arg("k_pe"), + py::arg("kv_cache_base"), + py::arg("reuse_cache_page_indice"), + py::arg("batch_reuse_info_vec"), + py::arg("qo_indptr"), + py::arg("tokens_per_block")); + + // ── MLA K Merge ───────────────────────────────────────────────────────── + rtp_ops_m.def("mla_k_merge", + [](at::Tensor& k_out, + const at::Tensor& k_nope, + const at::Tensor& k_pe) { + auto merged = at::cat({k_nope, k_pe}, -1); + k_out.copy_(merged); + }, + "MLA K merge (PyTorch fallback on XPU)", + py::arg("k_out"), + py::arg("k_nope"), + py::arg("k_pe")); + + // ── CUDA Graph Copy (no-op on XPU) ────────────────────────────────────── + rtp_ops_m.def("cuda_graph_copy_small2large", + [](const at::Tensor&, at::Tensor&, + int64_t, int64_t, int64_t, + const at::Tensor&, int64_t, const at::Tensor&) { + TORCH_CHECK(false, "cuda_graph_copy_small2large is not supported on XPU."); + }, + "CUDA Graph small-to-large copy (not supported on XPU)", + py::arg("input_tensor"), + py::arg("output_tensor"), + py::arg("batch_size"), + py::arg("max_batch_size"), + py::arg("max_seq_len"), + py::arg("input_lengths"), + py::arg("hidden_size"), + py::arg("cu_seq_len")); + + rtp_ops_m.def("cuda_graph_copy_large2small", + [](const at::Tensor&, at::Tensor&, + int64_t, int64_t, int64_t, + const at::Tensor&, int64_t, const at::Tensor&) { + TORCH_CHECK(false, "cuda_graph_copy_large2small is not supported on XPU."); + }, + "CUDA Graph large-to-small copy (not supported on XPU)", + py::arg("input_tensor"), + py::arg("output_tensor"), + py::arg("batch_size"), + py::arg("max_batch_size"), + py::arg("max_seq_len"), + py::arg("input_lengths"), + py::arg("hidden_size"), + py::arg("cu_seq_len")); + + // ── Fast TopK v2 ──────────────────────────────────────────────────────── + rtp_ops_m.def("fast_topk_v2", + [](at::Tensor& score, + at::Tensor& indices, + at::Tensor& lengths, + py::object row_starts) { + TORCH_CHECK(row_starts.is_none(), + "fast_topk_v2: ragged layout (row_starts) is not yet supported on XPU. " + "Only dense/paged layout is supported."); + int64_t k = indices.size(-1); + TORCH_CHECK(k >= 0 && k <= score.size(-1), + "fast_topk_v2: k (", k, ") must be in [0, score.size(-1)=", score.size(-1), "]"); + TORCH_CHECK(lengths.dim() == 1 && lengths.size(0) == score.size(0), + "fast_topk_v2: lengths must be 1-D with length equal to score.size(0)=", score.size(0), + ", got shape [", lengths.sizes(), "]"); + // Validate lengths values are in [0, score.size(-1)]. + // lengths is int32 (matching CUDA FastTopKParams::lengths). + auto len_cpu = lengths.to(at::kCPU).to(at::kInt); + auto* len_ptr = len_cpu.data_ptr(); + for (int64_t i = 0; i < len_cpu.size(0); i++) { + TORCH_CHECK(len_ptr[i] >= 0 && len_ptr[i] <= score.size(-1), + "fast_topk_v2: lengths[", i, "]=", len_ptr[i], + " out of valid range [0, ", score.size(-1), "]"); + } + // Work on a copy so the caller's score tensor is not mutated; + // fast_topk_v2 only produces indices (CUDA semantics). + auto work = score.clone(); + auto len_dev = lengths.to(work.device()); + auto col_idx = at::arange(work.size(-1), work.options().dtype(at::kLong)); + auto mask = col_idx.unsqueeze(0) >= len_dev.unsqueeze(1); + work.masked_fill_(mask, -std::numeric_limits::infinity()); + auto topk_result = work.topk(k, -1); + auto topk_idx = std::get<1>(topk_result); + // Per CUDA semantics, fill positions beyond valid lengths with -1. + auto k_idx = at::arange(k, topk_idx.options().dtype(at::kLong)); + auto out_mask = k_idx.unsqueeze(0) >= len_dev.unsqueeze(1); + topk_idx.masked_fill_(out_mask, -1); + indices.copy_(topk_idx.to(indices.scalar_type())); + }, + "Fast TopK v2 (PyTorch fallback on XPU)", + py::arg("score"), + py::arg("indices"), + py::arg("lengths"), + py::arg("row_starts") = py::none()); + + // ── Fast TopK Transform Fused ─────────────────────────────────────────── + rtp_ops_m.def("fast_topk_transform_fused", + [](at::Tensor&, at::Tensor&, at::Tensor&, + py::object, at::Tensor&, py::object) { + TORCH_CHECK(false, "fast_topk_transform_fused not implemented on XPU."); + }, + "Fast TopK Transform Fused (not implemented on XPU)", + py::arg("score"), + py::arg("lengths"), + py::arg("dst_page_table"), + py::arg("src_page_table") = py::none(), + py::arg("cu_seqlens_q"), + py::arg("row_starts") = py::none()); + + // ── Fast TopK Transform Ragged Fused ──────────────────────────────────── + rtp_ops_m.def("fast_topk_transform_ragged_fused", + [](at::Tensor&, at::Tensor&, at::Tensor&, + at::Tensor&, py::object) { + TORCH_CHECK(false, "fast_topk_transform_ragged_fused not implemented on XPU."); + }, + "Fast TopK Transform Ragged Fused (not implemented on XPU)", + py::arg("score"), + py::arg("lengths"), + py::arg("topk_indices_ragged"), + py::arg("topk_indices_offset"), + py::arg("row_starts") = py::none()); + + // ── Indexer K quant and cache ─────────────────────────────────────────── + // KV cache quantization is not supported on XPU. + // Ensure the model config does not enable kv_cache_quant when running on XPU. + rtp_ops_m.def("indexer_k_quant_and_cache", + [](const at::Tensor&, py::object, + const at::Tensor&, int64_t, int64_t) { + TORCH_CHECK(false, + "indexer_k_quant_and_cache is not implemented on XPU. " + "KV cache quantization is not supported on Intel GPU. " + "Please disable kv_cache_quant in your model config."); + }, + "Indexer K quant and cache (not implemented on XPU - disable kv_cache_quant)", + py::arg("k"), + py::arg("kv_cache"), + py::arg("slot_mapping"), + py::arg("quant_block_size"), + py::arg("scale_fmt")); + + // ── CP Gather indexer K quant cache ───────────────────────────────────── + rtp_ops_m.def("cp_gather_indexer_k_quant_cache", + [](py::object, at::Tensor&, at::Tensor&, + const at::Tensor&, const at::Tensor&) { + TORCH_CHECK(false, "cp_gather_indexer_k_quant_cache not implemented on XPU."); + }, + "CP Gather indexer K quant cache (not implemented on XPU)", + py::arg("kv_cache"), + py::arg("dst_k"), + py::arg("dst_scale"), + py::arg("block_table"), + py::arg("cu_seq_lens")); + + // ── CP Gather and upconvert FP8 KV cache ─────────────────────────────── + rtp_ops_m.def("cp_gather_and_upconvert_fp8_kv_cache", + [](py::object, at::Tensor&, at::Tensor&, + const at::Tensor&, const at::Tensor&, + const at::Tensor&, int64_t) { + TORCH_CHECK(false, "cp_gather_and_upconvert_fp8_kv_cache not implemented on XPU."); + }, + "CP Gather and upconvert FP8 KV cache (not implemented on XPU)", + py::arg("src_cache"), + py::arg("dst_compressed_kv"), + py::arg("dst_k_pe"), + py::arg("block_table"), + py::arg("seq_lens"), + py::arg("workspace_starts"), + py::arg("batch_size")); + + // ── Concat and cache MLA ──────────────────────────────────────────────── + rtp_ops_m.def("concat_and_cache_mla", + [](const at::Tensor&, const at::Tensor&, + py::object, const at::Tensor&, + const std::string&, double) { + TORCH_CHECK(false, + "concat_and_cache_mla not implemented on XPU."); + }, + "Concat and cache MLA (not implemented on XPU)", + py::arg("kv_c"), + py::arg("k_pe"), + py::arg("kv_cache"), + py::arg("slot_mapping"), + py::arg("kv_cache_dtype"), + py::arg("scale")); +} + +} // namespace torch_ext diff --git a/rtp_llm/models_py/bindings/xpu/RegisterXpuOps.cc b/rtp_llm/models_py/bindings/xpu/RegisterXpuOps.cc new file mode 100644 index 0000000000..3b4d7b63f4 --- /dev/null +++ b/rtp_llm/models_py/bindings/xpu/RegisterXpuOps.cc @@ -0,0 +1,10 @@ +#include "rtp_llm/models_py/bindings/RegisterOps.h" +#include "rtp_llm/models_py/bindings/xpu/RegisterXpuBaseBindings.hpp" + +namespace rtp_llm { + +void registerPyModuleOps(py::module& rtp_ops_m) { + torch_ext::registerBaseXpuBindings(rtp_ops_m); +} + +} // namespace rtp_llm diff --git a/rtp_llm/models_py/bindings/xpu/XpuTorchExt.h b/rtp_llm/models_py/bindings/xpu/XpuTorchExt.h new file mode 100644 index 0000000000..689d7dfc91 --- /dev/null +++ b/rtp_llm/models_py/bindings/xpu/XpuTorchExt.h @@ -0,0 +1,9 @@ +#pragma once +// XpuTorchExt.h — XPU-specific includes and macros for rtp_llm_ops bindings. +// Equivalent of common/Torch_ext.h but without CUDA/HIP dependencies. + +#include +#include +#include + +namespace py = pybind11; diff --git a/rtp_llm/models_py/model_desc/disaggregate_qwen3.py b/rtp_llm/models_py/model_desc/disaggregate_qwen3.py index 43558aaea0..fcbf8f8135 100644 --- a/rtp_llm/models_py/model_desc/disaggregate_qwen3.py +++ b/rtp_llm/models_py/model_desc/disaggregate_qwen3.py @@ -25,6 +25,7 @@ PyModelOutputs, ) from rtp_llm.utils.model_weight import W +from rtp_llm.models_py.model_desc.block_map import select_block_map_for_layer from rtp_llm.utils.util import check_with_info @@ -467,6 +468,7 @@ def forward_micro_batch( self.send_mirco_batch_split_info(mirco_batch_inputs) for i, layer in enumerate(self.attention_layers[: self.layer_num]): for idx, mirco_batch_input in enumerate(mirco_batch_inputs): + select_block_map_for_layer(mirco_batch_input.attention_inputs, i) inputs = self.recv_from_ffn_service( mirco_batch_input.input_ids.shape[0] ) diff --git a/rtp_llm/models_py/modules/base/__init__.py b/rtp_llm/models_py/modules/base/__init__.py index 2e78e931a2..e36eebe1b2 100644 --- a/rtp_llm/models_py/modules/base/__init__.py +++ b/rtp_llm/models_py/modules/base/__init__.py @@ -24,7 +24,23 @@ # Determine device type and import architecture-specific modules device_type = get_device_type() -if device_type == DeviceType.ROCm: +if device_type == DeviceType.Xpu: + from rtp_llm.models_py.modules.base.xpu.activation import FusedSiluAndMul + from rtp_llm.models_py.modules.base.xpu.moe_gating import SigmoidGateScaleAdd + from rtp_llm.models_py.modules.base.xpu.norm import ( + AddBiasResLayerNorm, + FusedQKRMSNorm, + QKRMSNorm, + RMSNorm, + RMSResNorm, + ) + from rtp_llm.models_py.modules.base.xpu.not_implemented_ops import ( + FakeBalanceExpert, + GroupTopK, + IndexerOp, + ) + from rtp_llm.models_py.modules.base.xpu.select_topk import SelectTopk +elif device_type == DeviceType.ROCm: from rtp_llm.models_py.modules.base.rocm.activation import FusedSiluAndMul from rtp_llm.models_py.modules.base.rocm.moe_gating import SigmoidGateScaleAdd from rtp_llm.models_py.modules.base.rocm.norm import ( diff --git a/rtp_llm/models_py/modules/base/common/embedding.py b/rtp_llm/models_py/modules/base/common/embedding.py index 964d3b4d77..eb34692a76 100755 --- a/rtp_llm/models_py/modules/base/common/embedding.py +++ b/rtp_llm/models_py/modules/base/common/embedding.py @@ -41,12 +41,25 @@ def forward( ) -> torch.Tensor: tokens = input.size(0) hidden_size = self.weight.size(-1) - output = torch.empty( - (tokens, hidden_size), dtype=self.weight.dtype, device=input.device - ) - rtp_llm_ops.embedding( - output, input, self.weight.data, position_ids, token_types, text_tokens_mask - ) + if not hasattr(rtp_llm_ops, 'embedding'): + # The F.embedding fallback cannot honor multimodal mask / position / + # token-type semantics. Continuing would silently produce wrong + # output, so fail-fast when any of those inputs is actually present. + if (text_tokens_mask is not None and text_tokens_mask.numel() > 0) \ + or position_ids is not None or token_types is not None: + raise NotImplementedError( + "rtp_llm_ops.embedding is unavailable on this backend, but " + "text_tokens_mask/position_ids/token_types were provided. " + "The F.embedding fallback cannot reproduce these masking " + "semantics; refusing to run with silently incorrect output.") + output = F.embedding(input, self.weight.data) + else: + output = torch.empty( + (tokens, hidden_size), dtype=self.weight.dtype, device=input.device + ) + rtp_llm_ops.embedding( + output, input, self.weight.data, position_ids, token_types, text_tokens_mask + ) if self.tp_size > 1: m, n = output.shape output = all_gather(output, group=Group.TP) diff --git a/rtp_llm/models_py/modules/base/xpu/__init__.py b/rtp_llm/models_py/modules/base/xpu/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/rtp_llm/models_py/modules/base/xpu/activation.py b/rtp_llm/models_py/modules/base/xpu/activation.py new file mode 100644 index 0000000000..bfcccd12de --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/activation.py @@ -0,0 +1,24 @@ +"""XPU-specific activation function implementations.""" +import torch + +from rtp_llm.models_py.modules.base.common.activation import SiluAndMulBase + +try: + from rtp_llm.models_py.modules.base.xpu.vllm_xpu_ops import is_available as _vllm_available +except ImportError: + _vllm_available = lambda: False + + +class FusedSiluAndMul(SiluAndMulBase): + """XPU SiLU-and-mul using vllm-xpu-kernels.""" + + def forward(self, gate_up: torch.Tensor) -> torch.Tensor: + d = gate_up.shape[-1] // 2 + output_shape = gate_up.shape[:-1] + (d,) + output = torch.empty(output_shape, dtype=gate_up.dtype, device=gate_up.device) + if _vllm_available() and gate_up.is_xpu: + torch.ops._C.silu_and_mul(output, gate_up) + else: + x, gate = gate_up[..., :d], gate_up[..., d:] + output.copy_(torch.nn.functional.silu(x) * gate) + return output diff --git a/rtp_llm/models_py/modules/base/xpu/moe_gating.py b/rtp_llm/models_py/modules/base/xpu/moe_gating.py new file mode 100644 index 0000000000..e18fe3556b --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/moe_gating.py @@ -0,0 +1,20 @@ +"""XPU MoE gating - PyTorch fallback.""" +import torch +import torch.nn as nn + + +class SigmoidGateScaleAdd(nn.Module): + def forward(self, gate: torch.Tensor, shared: torch.Tensor, experts: torch.Tensor) -> torch.Tensor: + assert gate.ndim == 2 and gate.shape[0] == experts.shape[0] and gate.shape[1] == 1, ( + f"SigmoidGateScaleAdd: gate must be [T, 1], got {gate.shape} " + f"vs experts {experts.shape}" + ) + assert shared.shape == experts.shape, ( + f"SigmoidGateScaleAdd: shared/experts shape mismatch: " + f"shared={shared.shape}, experts={experts.shape}" + ) + # Accumulate the gate scaling in fp32 to match the CUDA Triton kernel's + # precision, then cast back to the experts dtype before the in-place add. + scaled = (torch.sigmoid(gate.float()) * shared.float()).to(experts.dtype) + experts.add_(scaled) + return experts diff --git a/rtp_llm/models_py/modules/base/xpu/norm.py b/rtp_llm/models_py/modules/base/xpu/norm.py new file mode 100644 index 0000000000..2f62bd4c26 --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/norm.py @@ -0,0 +1,168 @@ +"""XPU-specific normalization implementations. + +Uses vllm-xpu-kernels ops when available, PyTorch fallbacks otherwise. +""" +from typing import Optional, Tuple + +import torch +from torch import nn + +from rtp_llm.models_py.modules.base.common.norm import ( + BaseAddBiasResLayerNorm, + BaseNorm, + BaseResNorm, +) + +try: + from rtp_llm.models_py.modules.base.xpu.vllm_xpu_ops import is_available as _vllm_available +except ImportError: + _vllm_available = lambda: False + + +def _can_use_vllm(tensor: torch.Tensor) -> bool: + """Check if vllm-xpu-kernels ops can run on this tensor's device.""" + return _vllm_available() and tensor.is_xpu + + +class RMSNorm(BaseNorm): + """XPU RMSNorm using vllm-xpu-kernels.""" + + def __init__(self, weight: torch.Tensor, eps: float = 1e-6): + super().__init__(weight, eps) + + def forward( + self, hidden_states: torch.Tensor, output: Optional[torch.Tensor] = None + ) -> torch.Tensor: + if _can_use_vllm(hidden_states): + if output is None: + output = torch.empty_like(hidden_states) + torch.ops._C.rms_norm(output, hidden_states, self.weight.data, self.variance_epsilon) + return output + # PyTorch fallback + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + variance = hidden_states.pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) + result = (self.weight * hidden_states).to(input_dtype) + if output is not None: + output.copy_(result) + return output + return result + + +class RMSResNorm(BaseResNorm): + """XPU fused add + RMSNorm. + + Semantics (matching vllm fused_add_rms_norm): + - residual is updated IN-PLACE to: residual + hidden_states + - Returns RMSNorm(new_residual) + """ + + def __init__(self, weight: torch.Tensor, eps: float = 1e-6): + super().__init__(weight, eps) + + def forward(self, hidden_states: torch.Tensor, residual: torch.Tensor): + if _can_use_vllm(hidden_states): + torch.ops._C.fused_add_rms_norm(hidden_states, residual, self.weight.data, self.variance_epsilon) + return hidden_states, residual + # PyTorch fallback — must update both residual and hidden_states in-place + # to match vllm fused_add_rms_norm semantics: + # residual <- residual + hidden_states + # hidden_states <- RMSNorm(new_residual) + residual.add_(hidden_states) + input_dtype = residual.dtype + r_float = residual.to(torch.float32) + variance = r_float.pow(2).mean(-1, keepdim=True) + normed = r_float * torch.rsqrt(variance + self.variance_epsilon) + result = (self.weight * normed).to(input_dtype) + hidden_states.copy_(result) + return hidden_states, residual + + +class QKRMSNorm(nn.Module): + """XPU QK-RMSNorm using composition of RMSNorm.""" + + def __init__( + self, + q_weight: torch.Tensor, + k_weight: torch.Tensor, + head_num: int, + kv_head_num: int, + size_per_head: float = 128, + eps: float = 1e-6, + ): + super().__init__() + self.q_norm = RMSNorm(q_weight, eps) + self.k_norm = RMSNorm(k_weight, eps) + self.head_num = head_num + self.kv_head_num = kv_head_num + self.size_per_head = int(size_per_head) + self.q_size = self.head_num * self.size_per_head + self.kv_size = self.kv_head_num * self.size_per_head + self.variance_epsilon = eps + + def _apply_qk_norm( + self, q: torch.Tensor, k: torch.Tensor + ) -> Tuple[torch.Tensor, torch.Tensor]: + q_by_head = q.reshape(-1, self.size_per_head) + q_by_head = self.q_norm(q_by_head) + q = q_by_head.view(q.shape) + k_by_head = k.reshape(-1, self.size_per_head) + k_by_head = self.k_norm(k_by_head) + k = k_by_head.view(k.shape) + return q, k + + def forward(self, hidden_states): + if _can_use_vllm(hidden_states): + # Normalize Q and K, write back to hidden_states + q_slice = hidden_states[..., :self.q_size] + q_flat = q_slice.reshape(-1, self.size_per_head) + q_out = torch.empty_like(q_flat) + torch.ops._C.rms_norm(q_out, q_flat, self.q_norm.weight.data, self.variance_epsilon) + q_slice.copy_(q_out.view_as(q_slice)) + + ks = self.q_size + k_slice = hidden_states[..., ks:ks + self.kv_size] + k_flat = k_slice.reshape(-1, self.size_per_head) + k_out = torch.empty_like(k_flat) + torch.ops._C.rms_norm(k_out, k_flat, self.k_norm.weight.data, self.variance_epsilon) + k_slice.copy_(k_out.view_as(k_slice)) + + return hidden_states + + q_slice, k_slice, _ = hidden_states.split([self.q_size, self.kv_size, self.kv_size], dim=-1) + q, k = self._apply_qk_norm(q_slice, k_slice) + q_slice.copy_(q) + k_slice.copy_(k) + return hidden_states + +# FusedQKRMSNorm - same as QKRMSNorm for XPU (no special fused kernel) +FusedQKRMSNorm = QKRMSNorm + + +class AddBiasResLayerNorm(BaseAddBiasResLayerNorm): + """XPU AddBiasResLayerNorm with empty-bias guard. + + When bias.numel()==0 (e.g. models without attention output bias), skip the + bias addition to avoid a shape-mismatch crash on XPU. + """ + + def __init__(self, weight: torch.Tensor, beta: torch.Tensor, eps: float = 1e-6): + super().__init__(weight, beta, eps) + + def forward( + self, hidden_states: torch.Tensor, residual: torch.Tensor, bias: torch.Tensor + ): + if bias.numel() == 0: + hidden_states = hidden_states + residual + else: + hidden_states = hidden_states + bias + residual + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + mean = hidden_states.mean(dim=-1, keepdim=True) + centered = hidden_states - mean + variance = centered.pow(2).mean(dim=-1, keepdim=True) + x_normalized = centered / torch.sqrt( + variance + self.variance_epsilon + ) + return (self.weight * x_normalized + self.beta).to(input_dtype) diff --git a/rtp_llm/models_py/modules/base/xpu/not_implemented_ops.py b/rtp_llm/models_py/modules/base/xpu/not_implemented_ops.py new file mode 100644 index 0000000000..383b4213c4 --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/not_implemented_ops.py @@ -0,0 +1,24 @@ +"""XPU stubs for ops not yet needed (MoE, deep_gemm, etc.).""" + +from rtp_llm.models_py.modules.base.not_implemented import NotImplementedOp + + +class GroupTopK(NotImplementedOp): + """GroupTopK is not implemented for XPU.""" + + def __init__(self, *args, **kwargs): + super().__init__(op_name="GroupTopK", device_type="XPU") + + +class FakeBalanceExpert(NotImplementedOp): + """FakeBalanceExpert is not implemented for XPU.""" + + def __init__(self, *args, **kwargs): + super().__init__(op_name="FakeBalanceExpert", device_type="XPU") + + +class IndexerOp(NotImplementedOp): + """IndexerOp is not implemented for XPU.""" + + def __init__(self, *args, **kwargs): + super().__init__(op_name="IndexerOp", device_type="XPU") diff --git a/rtp_llm/models_py/modules/base/xpu/select_topk.py b/rtp_llm/models_py/modules/base/xpu/select_topk.py new file mode 100644 index 0000000000..1dea698fea --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/select_topk.py @@ -0,0 +1,31 @@ +"""XPU MoE Top-K selection - PyTorch fallback. + +Mirrors the CUDA ``SelectTopkOp`` semantics: softmax over all experts, take the +top-k experts, and (when the model uses MoE normalization, ``has_moe_norm``) +renormalize the selected weights to sum to 1. Results are written in place into +the caller's ``topk_ids`` / ``topk_weights`` tensors, matching the CUDA op. +""" +import torch +from torch import nn + +from rtp_llm.config.model_config import ModelConfig + + +class SelectTopk(nn.Module): + def __init__(self, config: ModelConfig): + super().__init__() + self.top_k = config.moe_k + self.renormalize = config.has_moe_norm + + def forward( + self, + router_logits_fp32: torch.Tensor, + topk_ids: torch.Tensor, + topk_weights: torch.Tensor, + ): + probs = torch.softmax(router_logits_fp32.float(), dim=-1) + weights, ids = torch.topk(probs, self.top_k, dim=-1) + if self.renormalize: + weights = weights / weights.sum(dim=-1, keepdim=True).clamp(min=1e-9) + topk_weights.copy_(weights.to(topk_weights.dtype)) + topk_ids.copy_(ids.to(topk_ids.dtype)) diff --git a/rtp_llm/models_py/modules/base/xpu/vllm_xpu_ops.py b/rtp_llm/models_py/modules/base/xpu/vllm_xpu_ops.py new file mode 100644 index 0000000000..b27d16ab11 --- /dev/null +++ b/rtp_llm/models_py/modules/base/xpu/vllm_xpu_ops.py @@ -0,0 +1,207 @@ +"""Wrapper around vllm-xpu-kernels ops for use in rtp-llm. + +Provides optimized SYCL/DPC++ kernels for Intel XPU via vllm-xpu-kernels. +Falls back to PyTorch native ops when vllm-xpu-kernels is not available. +""" + +import logging +import os +import sys + +import torch + +logger = logging.getLogger(__name__) + +_VLLM_XPU_AVAILABLE = False +_FA2_AVAILABLE = False +_MOE_AVAILABLE = False + +# If vllm-xpu-kernels is pip-installed, import works directly. +# Only use VLLM_XPU_KERNELS_PATH for development / editable installs. +_vllm_xpu_root = os.environ.get("VLLM_XPU_KERNELS_PATH", "") +if _vllm_xpu_root and os.path.isdir(_vllm_xpu_root) and _vllm_xpu_root not in sys.path: + sys.path.insert(0, _vllm_xpu_root) + +try: + import vllm_xpu_kernels._C # noqa: F401 + _VLLM_XPU_AVAILABLE = True + logger.info("vllm-xpu-kernels _C loaded") +except (ImportError, OSError, RuntimeError) as exc: + logger.warning("vllm-xpu-kernels _C not available: %s", exc) + +try: + import vllm_xpu_kernels._vllm_fa2_C # noqa: F401 + _FA2_AVAILABLE = True + logger.info("vllm-xpu-kernels FA2 loaded") +except (ImportError, OSError, RuntimeError) as exc: + logger.warning("vllm-xpu-kernels FA2 not available: %s", exc) + +try: + import vllm_xpu_kernels._moe_C # noqa: F401 + import vllm_xpu_kernels._xpu_C # noqa: F401 + _MOE_AVAILABLE = True + logger.info("vllm-xpu-kernels MoE loaded") +except (ImportError, OSError, RuntimeError) as exc: + logger.warning("vllm-xpu-kernels MoE not available: %s", exc) + + +def is_available(): + return _VLLM_XPU_AVAILABLE + +def is_fa2_available(): + return _FA2_AVAILABLE + +def is_moe_available(): + return _MOE_AVAILABLE + + +def rms_norm(result, input, weight, epsilon): + if _VLLM_XPU_AVAILABLE: + torch.ops._C.rms_norm(result, input, weight, epsilon) + else: + variance = input.pow(2).mean(-1, keepdim=True) + normed = input * torch.rsqrt(variance + epsilon) + result.copy_(normed * weight) + + +def fused_add_rms_norm(input, residual, weight, epsilon): + if _VLLM_XPU_AVAILABLE: + torch.ops._C.fused_add_rms_norm(input, residual, weight, epsilon) + else: + residual.add_(input) + variance = residual.pow(2).mean(-1, keepdim=True) + normed = residual * torch.rsqrt(variance + epsilon) + input.copy_(normed * weight) + + +def silu_and_mul(out, input): + if _VLLM_XPU_AVAILABLE: + torch.ops._C.silu_and_mul(out, input) + else: + d = input.shape[-1] // 2 + x, gate = input[..., :d], input[..., d:] + out.copy_(torch.nn.functional.silu(x) * gate) + + +def gelu_and_mul(out, input): + if _VLLM_XPU_AVAILABLE: + torch.ops._C.gelu_and_mul(out, input) + else: + d = input.shape[-1] // 2 + x, gate = input[..., :d], input[..., d:] + out.copy_(torch.nn.functional.gelu(x) * gate) + + +def rotary_embedding(positions, query, key, head_size, cos_sin_cache, is_neox=True): + if _VLLM_XPU_AVAILABLE: + torch.ops._C.rotary_embedding(positions, query, key, head_size, cos_sin_cache, is_neox) + else: + # PyTorch fallback: apply rotary embeddings using cos/sin cache + rotary_dim = cos_sin_cache.shape[-1] + half_dim = rotary_dim // 2 + cos_sin = cos_sin_cache[positions.long()] + cos = cos_sin[:, :half_dim] + sin = cos_sin[:, half_dim:] + # Apply to query + _apply_rotary_inplace(query, cos, sin, head_size, half_dim, is_neox) + # Apply to key + _apply_rotary_inplace(key, cos, sin, head_size, half_dim, is_neox) + + +def _apply_rotary_inplace(x, cos, sin, head_size, half_dim, is_neox): + """Apply rotary embedding in-place to a [num_tokens, num_heads * head_size] tensor.""" + num_tokens = x.shape[0] + total = x.shape[-1] + num_heads = total // head_size + x_view = x.view(num_tokens, num_heads, head_size) + if is_neox: + x1 = x_view[..., :half_dim] + x2 = x_view[..., half_dim:2*half_dim] + cos_e = cos.unsqueeze(1) + sin_e = sin.unsqueeze(1) + o1 = x1 * cos_e - x2 * sin_e + o2 = x2 * cos_e + x1 * sin_e + x_view[..., :half_dim] = o1 + x_view[..., half_dim:2*half_dim] = o2 + else: + # Interleaved style + x1 = x_view[..., 0:2*half_dim:2] + x2 = x_view[..., 1:2*half_dim:2] + cos_e = cos.unsqueeze(1) + sin_e = sin.unsqueeze(1) + o1 = x1 * cos_e - x2 * sin_e + o2 = x2 * cos_e + x1 * sin_e + x_view[..., 0:2*half_dim:2] = o1 + x_view[..., 1:2*half_dim:2] = o2 + + +def flash_attn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_k, + max_seqlen_q, max_seqlen_k, + softmax_scale=None, causal=True, + block_table=None, seqused_k=None): + if _FA2_AVAILABLE: + from vllm_xpu_kernels.flash_attn_interface import flash_attn_varlen_func + # block_table requires seqused_k and forbids cu_seqlens_k + if block_table is not None: + return flash_attn_varlen_func( + q, k, v, + max_seqlen_q=max_seqlen_q, + cu_seqlens_q=cu_seqlens_q, + max_seqlen_k=max_seqlen_k, + seqused_k=seqused_k, + softmax_scale=softmax_scale, + causal=causal, + block_table=block_table, + ) + return flash_attn_varlen_func( + q, k, v, + max_seqlen_q=max_seqlen_q, + cu_seqlens_q=cu_seqlens_q, + max_seqlen_k=max_seqlen_k, + cu_seqlens_k=cu_seqlens_k, + seqused_k=seqused_k, + softmax_scale=softmax_scale, + causal=causal, + block_table=block_table, + ) + else: + if block_table is not None: + raise RuntimeError( + "flash_attn_varlen SDPA fallback does not support block_table (paged KV cache). " + "Install vllm-xpu-kernels to enable paged attention on XPU." + ) + if seqused_k is not None: + raise RuntimeError( + "flash_attn_varlen SDPA fallback does not support seqused_k. " + "Install vllm-xpu-kernels to enable this feature on XPU.") + return _sdpa_varlen_fallback(q, k, v, cu_seqlens_q, cu_seqlens_k, + max_seqlen_q, max_seqlen_k, softmax_scale, causal) + + +def _sdpa_varlen_fallback(q, k, v, cu_seqlens_q, cu_seqlens_k, + max_seqlen_q, max_seqlen_k, softmax_scale, causal): + assert cu_seqlens_q is not None and cu_seqlens_k is not None, \ + "_sdpa_varlen_fallback requires cu_seqlens_q/cu_seqlens_k" + import torch.nn.functional as F + # Copy cu_seqlens to CPU once to avoid per-request D2H sync in the loop. + cu_q_cpu = cu_seqlens_q.cpu() if cu_seqlens_q.is_cuda or (hasattr(cu_seqlens_q, 'is_xpu') and cu_seqlens_q.is_xpu) else cu_seqlens_q + cu_k_cpu = cu_seqlens_k.cpu() if cu_seqlens_k.is_cuda or (hasattr(cu_seqlens_k, 'is_xpu') and cu_seqlens_k.is_xpu) else cu_seqlens_k + batch_size = cu_q_cpu.numel() - 1 + outputs = [] + scale = softmax_scale or (q.shape[-1] ** -0.5) + for i in range(batch_size): + q_start, q_end = cu_q_cpu[i].item(), cu_q_cpu[i + 1].item() + k_start, k_end = cu_k_cpu[i].item(), cu_k_cpu[i + 1].item() + qi = q[q_start:q_end].unsqueeze(0).transpose(1, 2) + ki = k[k_start:k_end].unsqueeze(0).transpose(1, 2) + vi = v[k_start:k_end].unsqueeze(0).transpose(1, 2) + # GQA/MQA: repeat K/V heads to match Q head count for SDPA. + if qi.shape[1] != ki.shape[1]: + n_rep = qi.shape[1] // ki.shape[1] + ki = ki.repeat_interleave(n_rep, dim=1) + vi = vi.repeat_interleave(n_rep, dim=1) + oi = F.scaled_dot_product_attention(qi, ki, vi, is_causal=causal, scale=scale) + outputs.append(oi.transpose(1, 2).squeeze(0)) + if outputs: + return torch.cat(outputs, dim=0) + return q.new_empty(0, q.shape[1], q.shape[2]) diff --git a/rtp_llm/models_py/modules/factory/attention/__init__.py b/rtp_llm/models_py/modules/factory/attention/__init__.py index d9527dc644..67e046ba7f 100755 --- a/rtp_llm/models_py/modules/factory/attention/__init__.py +++ b/rtp_llm/models_py/modules/factory/attention/__init__.py @@ -28,7 +28,16 @@ ) device_type = get_device_type() -if device_type == DeviceType.ROCm: +if device_type == DeviceType.Xpu: + # XPU hard-requires the accelerated vllm-xpu-kernels attention path, + # matching the CUDA and ROCm backends (no pure-PyTorch attention fallback). + from rtp_llm.models_py.modules.factory.attention.xpu_impl.vllm_flash_attn import ( + XpuVllmFlashAttnPrefillImpl, + XpuVllmFlashAttnDecodeImpl, + ) + PREFILL_MHA_IMPS.append(XpuVllmFlashAttnPrefillImpl) + DECODE_MHA_IMPS.append(XpuVllmFlashAttnDecodeImpl) +elif device_type == DeviceType.ROCm: # Import to register ROCm FMHA implementations from rtp_llm.models_py.modules.factory.attention.rocm_impl.aiter import ( AiterDecodeImplAsm, diff --git a/rtp_llm/models_py/modules/factory/attention/common.py b/rtp_llm/models_py/modules/factory/attention/common.py index 16a5e366cb..ae4c3741c1 100644 --- a/rtp_llm/models_py/modules/factory/attention/common.py +++ b/rtp_llm/models_py/modules/factory/attention/common.py @@ -75,6 +75,8 @@ def apply_write_cache_store( attn_inputs: Attention calculation input parameters kv_cache: KV Cache to write to """ + if kv_cache is None: + return if ( attn_inputs.is_prefill and attn_inputs.cache_store_inputs diff --git a/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/BUILD b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/BUILD new file mode 100644 index 0000000000..215d4d0251 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/BUILD @@ -0,0 +1,28 @@ +# Tests for XPU paged flash attention helpers. +# +# - test_kv_cache_layout: verifies KVCache::getLayerCache() (OpDefs.h XPU branch) +# produces the NSHD KV layout the vllm_flash_attn consumer reads/writes. +# - test_no_rope: verifies RoPE is skipped for RopeStyle.No models. +# +# Pure Python tests; use py_standalone_testlib (no compiled C++ .so required +# at analysis time), matching the ROCm test convention. + +py_test_deps = [ + "//rtp_llm/models_py/standalone:py_standalone_testlib", +] + +py_test( + name = "test_kv_cache_layout", + srcs = ["test_kv_cache_layout.py"], + deps = py_test_deps, + timeout = "short", + tags = ["xpu"], +) + +py_test( + name = "test_no_rope", + srcs = ["test_no_rope.py"], + deps = py_test_deps, + timeout = "short", + tags = ["xpu"], +) diff --git a/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_kv_cache_layout.py b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_kv_cache_layout.py new file mode 100644 index 0000000000..e1ba0e7e71 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_kv_cache_layout.py @@ -0,0 +1,102 @@ +"""XPU KV cache layout consistency test. + +Verifies that the KV cache layout produced by KVCache::getLayerCache() (XPU +branch in rtp_llm/models_py/bindings/OpDefs.h) matches what the XPU paged flash +attention consumer in vllm_flash_attn.py reads and writes. + +The XPU layout is NSHD: [num_blocks, 2, seq_size_per_block, num_kv_heads, +head_dim] (seq before head), which differs from the CUDA HND layout +[num_blocks, 2, num_kv_heads, seq_size_per_block, head_dim]. This test guards +against silent producer/consumer drift. It is CPU-runnable (no XPU device +required); it only needs the compiled rtp_llm.ops bindings for KVCache. +""" + +from unittest import SkipTest, TestCase, main + +import torch + +try: + from rtp_llm.ops.compute_ops import CacheGroupType, KVCache + from rtp_llm.models_py.modules.factory.attention.xpu_impl.vllm_flash_attn import ( + _assert_nshd_cache, + _read_from_paged_cache, + _write_to_paged_cache, + ) + _IMPORT_OK = True +except Exception as _e: # pragma: no cover - import-time environment guard + _IMPORT_OK = False + _IMPORT_ERR = _e + +# Distinct seq/head so the NSHD vs HND axis order is unambiguous. +NUM_BLOCKS = 4 +TPB = 8 # seq_size_per_block +NUM_KV_HEADS = 3 +HEAD_DIM = 16 + + +class XpuKVCacheLayoutTest(TestCase): + def setUp(self): + if not _IMPORT_OK: + raise SkipTest(f"rtp_llm.ops / xpu consumer unavailable: {_IMPORT_ERR}") + + def _make_layer_cache(self): + # Physical 2-D block buffer: [num_blocks, 2*tpb*heads*dim]. + base = torch.zeros(NUM_BLOCKS, 2 * TPB * NUM_KV_HEADS * HEAD_DIM, dtype=torch.float32) + kv = KVCache() + kv.seq_size_per_block = TPB + kv.kernel_seq_size_per_block = TPB + kv.num_kv_heads = NUM_KV_HEADS + kv.head_dim = HEAD_DIM + kv.use_mla = False + kv.kv_cache_base_by_layer = [base] + kv.layer_attn_types = [CacheGroupType.FULL] + return kv.get_layer_cache(0) + + def test_producer_layout_is_nshd(self): + lc = self._make_layer_cache() + shape = tuple(lc.kv_cache_base.shape) + expected = (NUM_BLOCKS, 2, TPB, NUM_KV_HEADS, HEAD_DIM) + if shape != expected: + # Non-XPU build: getLayerCache emits HND; the XPU consumer is not + # used there, so this linkage assertion does not apply. + raise SkipTest(f"non-XPU getLayerCache layout {shape}; expected NSHD {expected}") + self.assertEqual(lc.seq_size_per_block, TPB) + + def test_write_read_roundtrip_matches_producer(self): + lc = self._make_layer_cache() + if tuple(lc.kv_cache_base.shape) != (NUM_BLOCKS, 2, TPB, NUM_KV_HEADS, HEAD_DIM): + raise SkipTest("non-XPU getLayerCache layout; consumer linkage N/A") + total = NUM_BLOCKS * TPB + torch.manual_seed(0) + k_in = torch.randn(total, NUM_KV_HEADS, HEAD_DIM) + v_in = torch.randn(total, NUM_KV_HEADS, HEAD_DIM) + bids = torch.arange(NUM_BLOCKS, dtype=torch.long) + + _write_to_paged_cache(k_in, v_in, lc, bids, 0, NUM_KV_HEADS, HEAD_DIM) + k_out, v_out = _read_from_paged_cache(lc, bids, total, NUM_KV_HEADS, HEAD_DIM) + + self.assertTrue(torch.equal(k_in, k_out)) + self.assertTrue(torch.equal(v_in, v_out)) + + # Token 0 must land at NSHD position cache[block0, k=0, off0, :, :]. + cache = lc.kv_cache_base + self.assertTrue(torch.equal(k_in[0], cache[0, 0, 0, :, :])) + self.assertTrue(torch.equal(v_in[0], cache[0, 1, 0, :, :])) + + def test_guard_rejects_hnd_layout(self): + if not _IMPORT_OK: + raise SkipTest("consumer unavailable") + # HND tensor [blocks, 2, heads, seq, dim] must be rejected. + hnd = torch.zeros(NUM_BLOCKS, 2, NUM_KV_HEADS, TPB, HEAD_DIM) + with self.assertRaises(RuntimeError): + _assert_nshd_cache(hnd, TPB, NUM_KV_HEADS, HEAD_DIM) + + def test_guard_accepts_nshd_layout(self): + if not _IMPORT_OK: + raise SkipTest("consumer unavailable") + nshd = torch.zeros(NUM_BLOCKS, 2, TPB, NUM_KV_HEADS, HEAD_DIM) + _assert_nshd_cache(nshd, TPB, NUM_KV_HEADS, HEAD_DIM) # must not raise + + +if __name__ == "__main__": + main() diff --git a/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_no_rope.py b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_no_rope.py new file mode 100644 index 0000000000..8f1afb0981 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/attention/xpu_impl/test/test_no_rope.py @@ -0,0 +1,136 @@ +"""Unit test: RopeStyle.No models must NOT invoke _apply_rope. + +Verifies that both XpuVllmPrefillImpl and XpuVllmDecodeImpl skip RoPE +application when rope_config.style == RopeStyle.No or rope_config is None. +CPU-runnable (no XPU device required). +""" + +from unittest import TestCase, main, SkipTest +from unittest.mock import patch + +import torch + +try: + from rtp_llm.ops import RopeStyle + from rtp_llm.models_py.modules.factory.attention.xpu_impl.vllm_flash_attn import ( + _need_rope, + _split_qkv_and_rope, + ) + _IMPORT_OK = True +except Exception as _e: + _IMPORT_OK = False + _IMPORT_ERR = _e + + +class _FakeRopeConfig: + def __init__(self, style): + self.style = style + self.dim = 0 + self.base = 10000.0 + self.scale = 1.0 + self.is_neox_style = True + + +class _FakeAttnConfigs: + def __init__(self, rope_config=None, need_rope_kv_cache=False): + self.rope_config = rope_config + self.need_rope_kv_cache = need_rope_kv_cache + self.head_num = 4 + self.kv_head_num = 4 + self.size_per_head = 16 + + +class _FakeAttnInputs: + def __init__(self): + self.is_prefill = True + self.input_lengths = None + self.prefix_lengths = None + self.position_ids = None + self.sequence_lengths = None + + +class TestNeedRope(TestCase): + def setUp(self): + if not _IMPORT_OK: + raise SkipTest(f"Import failed: {_IMPORT_ERR}") + + def test_no_rope_style_returns_false(self): + cfg = _FakeAttnConfigs(rope_config=_FakeRopeConfig(RopeStyle.No)) + self.assertFalse(_need_rope(cfg)) + + def test_rope_config_none_returns_false(self): + cfg = _FakeAttnConfigs(rope_config=None) + self.assertFalse(_need_rope(cfg)) + + def test_base_rope_style_returns_true(self): + cfg = _FakeAttnConfigs(rope_config=_FakeRopeConfig(RopeStyle.Base)) + self.assertTrue(_need_rope(cfg)) + + def test_need_rope_kv_cache_overrides(self): + cfg = _FakeAttnConfigs(rope_config=None, need_rope_kv_cache=True) + self.assertTrue(_need_rope(cfg)) + + +class TestSplitQkvNoRope(TestCase): + """Verify _split_qkv_and_rope does NOT call _apply_rope when need_rope=False.""" + + def setUp(self): + if not _IMPORT_OK: + raise SkipTest(f"Import failed: {_IMPORT_ERR}") + + @patch( + "rtp_llm.models_py.modules.factory.attention.xpu_impl.vllm_flash_attn._apply_rope", + side_effect=AssertionError("_apply_rope should not be called for No-RoPE"), + ) + def test_no_rope_skips_apply_rope(self, mock_apply): + num_heads = 4 + num_kv_heads = 4 + head_dim = 16 + total_tokens = 2 + qkv_size = (num_heads + 2 * num_kv_heads) * head_dim + qkv = torch.randn(total_tokens, qkv_size) + + rope_config = _FakeRopeConfig(RopeStyle.No) + attn_inputs = _FakeAttnInputs() + + # need_rope=False: must NOT invoke _apply_rope + q, k, v = _split_qkv_and_rope( + qkv, attn_inputs, num_heads, num_kv_heads, + head_dim, rope_config, need_rope=False, + ) + + mock_apply.assert_not_called() + # Verify shapes + self.assertEqual(q.shape, (total_tokens, num_heads, head_dim)) + self.assertEqual(k.shape, (total_tokens, num_kv_heads, head_dim)) + self.assertEqual(v.shape, (total_tokens, num_kv_heads, head_dim)) + + @patch( + "rtp_llm.models_py.modules.factory.attention.xpu_impl.vllm_flash_attn._apply_rope", + side_effect=AssertionError("_apply_rope should not be called for None rope_config"), + ) + def test_none_rope_config_skips_apply_rope(self, mock_apply): + num_heads = 4 + num_kv_heads = 4 + head_dim = 16 + total_tokens = 2 + qkv_size = (num_heads + 2 * num_kv_heads) * head_dim + qkv = torch.randn(total_tokens, qkv_size) + + attn_inputs = _FakeAttnInputs() + cfg = _FakeAttnConfigs(rope_config=None) + + # _need_rope should return False for None rope_config + need_rope = _need_rope(cfg) + self.assertFalse(need_rope) + + q, k, v = _split_qkv_and_rope( + qkv, attn_inputs, num_heads, num_kv_heads, + head_dim, None, need_rope=False, + ) + + mock_apply.assert_not_called() + + +if __name__ == "__main__": + main() diff --git a/rtp_llm/models_py/modules/factory/attention/xpu_impl/vllm_flash_attn.py b/rtp_llm/models_py/modules/factory/attention/xpu_impl/vllm_flash_attn.py new file mode 100644 index 0000000000..c3546a09f4 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/attention/xpu_impl/vllm_flash_attn.py @@ -0,0 +1,924 @@ +"""XPU Flash Attention with RoPE and KV Cache using vllm-xpu-kernels. + +Supports batched multi-request decode and prefill for continuous batching. +Uses the framework's LayerKVCache for paged KV storage. Uses flash_attn_varlen +to handle variable-length sequences in a single kernel call. +""" + +import logging +import os +from collections import OrderedDict +from typing import Dict, Optional, Tuple + +import torch +import torch.nn.functional as F + +from rtp_llm.models_py.modules.factory.attention import common +from rtp_llm.models_py.modules.factory.attention.fmha_impl_base import FMHAImplBase +from rtp_llm.ops import AttentionConfigs, ParallelismConfig, RopeStyle +from rtp_llm.ops import KvCacheDataType +from rtp_llm.ops.compute_ops import LayerKVCache, PyAttentionInputs + +# RoPE styles unsupported by the XPU Base-frequency cache. +# Yarn/Llama3/Mrope require different freq computations; Glm2/DynamicNTK also +# use non-Base scaling. All of these produce silently wrong scores if run +# through the plain Base cache, so both XpuVllmPrefillImpl and +# XpuVllmDecodeImpl reject them in support(). +_UNSUPPORTED_ROPE_STYLES = { + RopeStyle.Glm2, + RopeStyle.DynamicNTK, + RopeStyle.QwenDynamicNTK, + RopeStyle.Yarn, + RopeStyle.Llama3, + RopeStyle.Mrope, +} + +logger = logging.getLogger(__name__) + +# Module-level lazy import for flash attention (avoids per-call import overhead) +_flash_attn_varlen = None +def _get_flash_attn_varlen(): + global _flash_attn_varlen + if _flash_attn_varlen is None: + from rtp_llm.models_py.modules.base.xpu.vllm_xpu_ops import flash_attn_varlen + _flash_attn_varlen = flash_attn_varlen + return _flash_attn_varlen + + +def _is_fa2_available() -> bool: + """Return True if the real FA2 kernel (vllm_fa2_C) is available. + + Must NOT test by importing flash_attn_varlen — that wrapper always + exists and falls back to SDPA. Instead delegate to the module-level + flag set by importing vllm_xpu_kernels._vllm_fa2_C. + """ + from rtp_llm.models_py.modules.base.xpu.vllm_xpu_ops import is_fa2_available + return is_fa2_available() + + +# ── Cached arange tensors (avoid per-layer recreation) ───────────────── +_arange_cache = {} # (max_size, device) -> tensor + +def _get_arange(size, dtype, device): + """Return a cached arange [0..size), growing the cache as needed.""" + key = str(device) + cached = _arange_cache.get(key) + if cached is not None and cached.numel() >= size: + return cached[:size].to(dtype=dtype) + t = torch.arange(max(size, 256), dtype=torch.int32, device=device) + _arange_cache[key] = t + return t[:size].to(dtype=dtype) + + +# ── RoPE ──────────────────────────────────────────────────────────────────── + +_COS_SIN_CACHE: OrderedDict = OrderedDict() +_COS_SIN_CACHE_MAX_SIZE = 32 + + +def reset_module_caches(): + """Release all module-level GPU tensor caches. Call on model unload.""" + _COS_SIN_CACHE.clear() + _PREFILL_WRITE_IDX_CACHE.clear() + _arange_cache.clear() + # Also drop the per-stream decode KV gather scratch buffers; these are GPU + # tensors retained on the decode impl and would otherwise leak on unload. + XpuVllmDecodeImpl.reset_decode_scratch() + +_VLLM_ROPE = None +_VLLM_ROPE_CHECKED = False + +def _get_vllm_rope(): + global _VLLM_ROPE, _VLLM_ROPE_CHECKED + if not _VLLM_ROPE_CHECKED: + _VLLM_ROPE_CHECKED = True + try: + from rtp_llm.models_py.modules.base.xpu.vllm_xpu_ops import rotary_embedding + _VLLM_ROPE = rotary_embedding + except ImportError: + pass + return _VLLM_ROPE + + + + +def _get_cos_sin_cache(rope_config, head_dim, max_pos, dtype, device): + rotary_dim = getattr(rope_config, 'dim', 0) or head_dim + base = getattr(rope_config, 'base', 10000.0) or 10000.0 + scale = getattr(rope_config, 'scale', 1.0) or 1.0 + key = (base, rotary_dim, max_pos, scale, dtype, str(device)) + if key in _COS_SIN_CACHE: + _COS_SIN_CACHE.move_to_end(key) + return _COS_SIN_CACHE[key] + # Evict oldest entries if cache is full + if len(_COS_SIN_CACHE) >= _COS_SIN_CACHE_MAX_SIZE: + oldest_key = next(iter(_COS_SIN_CACHE)) + del _COS_SIN_CACHE[oldest_key] + inv_freq = 1.0 / (base ** (torch.arange(0, rotary_dim, 2, dtype=torch.float32) / rotary_dim)) + t = torch.arange(max_pos, dtype=torch.float32) + if scale != 1.0: + t = t / scale + freqs = torch.outer(t, inv_freq) + cache = torch.cat((freqs.cos(), freqs.sin()), dim=-1) + cache = cache.to(dtype=dtype, device=device) + _COS_SIN_CACHE[key] = cache + return cache + + +def _apply_rotary_emb_neox(x, cos, sin): + d2 = cos.shape[-1] + x1, x2 = x[..., :d2], x[..., d2:2*d2] + x_pass = x[..., 2*d2:] + o1 = x1 * cos - x2 * sin + o2 = x2 * cos + x1 * sin + return torch.cat((o1, o2, x_pass), dim=-1) + + +def _apply_rotary_emb_gptj(x, cos, sin): + # GPT-J / non-neox style: rotate interleaved adjacent pairs + # (x[..., 0::2], x[..., 1::2]) rather than split halves. + d2 = cos.shape[-1] + x_rot = x[..., :2*d2] + x_pass = x[..., 2*d2:] + x_rot = x_rot.reshape(*x_rot.shape[:-1], d2, 2) + x1 = x_rot[..., 0] + x2 = x_rot[..., 1] + o1 = x1 * cos - x2 * sin + o2 = x2 * cos + x1 * sin + o = torch.stack((o1, o2), dim=-1).flatten(-2) + return torch.cat((o, x_pass), dim=-1) + + +def _need_rope(attn_configs): + if getattr(attn_configs, 'need_rope_kv_cache', False): + return True + rope_config = getattr(attn_configs, 'rope_config', None) + if rope_config is None: + return False + style = getattr(rope_config, 'style', RopeStyle.No) + return style != RopeStyle.No + + +def _apply_rope(q, k, positions, rope_config, head_dim, num_heads, num_kv_heads, device, dtype, max_pos_hint=None): + rotary_dim = getattr(rope_config, 'dim', 0) or head_dim + is_neox = getattr(rope_config, 'is_neox_style', True) + if max_pos_hint is not None: + raw_max = max(max_pos_hint + 1, 4096) + else: + raw_max = max(int(positions.max().item()) + 1, 4096) + # Round up to next power-of-2 to reduce unique cache entries + max_pos = 1 << (raw_max - 1).bit_length() + cos_sin_cache = _get_cos_sin_cache(rope_config, head_dim, max_pos, dtype, device) + vllm_rope = _get_vllm_rope() + if vllm_rope is None: + # Op genuinely unavailable: fall through to the Python path below. + if not getattr(_apply_rope, '_rope_fallback_warned', False): + logger.warning('vllm RoPE op unavailable, using Python fallback (perf degraded)') + _apply_rope._rope_fallback_warned = True + else: + # The kernel writes q/k in place. If it raises mid-write the tensors are + # already partially rotated, so re-raise instead of re-applying RoPE on + # corrupted data via the Python fallback. + vllm_rope(positions, q, k, head_dim, cos_sin_cache, is_neox) + return q, k + num_tokens = q.shape[0] + cos_sin = cos_sin_cache[positions.long()] + half = cos_sin.shape[-1] // 2 + cos = cos_sin[:, :half].unsqueeze(1) + sin = cos_sin[:, half:].unsqueeze(1) + q_r = q.view(num_tokens, num_heads, head_dim) + k_r = k.view(num_tokens, num_kv_heads, head_dim) + _rope_fn = _apply_rotary_emb_neox if is_neox else _apply_rotary_emb_gptj + q_r = _rope_fn(q_r, cos, sin) + k_r = _rope_fn(k_r, cos, sin) + return q_r.reshape(num_tokens, -1), k_r.reshape(num_tokens, -1) + + +def _build_prefill_positions(attn_inputs, total_tokens, device): + """Build per-token position IDs for a prefill batch. + + For batched prefill, concatenates ``arange(prefix_i, prefix_i + input_i)`` + so each sequence's RoPE positions start from its own prefix offset, not + from a global ``arange(total_tokens)`` (which would alias positions across + requests and produce wrong K). Handles prefix-cache prefill + (``prefix_lengths > 0``) by offsetting each request's position range. + """ + input_lengths = getattr(attn_inputs, 'input_lengths', None) + if input_lengths is None or input_lengths.numel() == 0: + return torch.arange(total_tokens, dtype=torch.long, device=device) + input_lengths_cpu = input_lengths if input_lengths.is_cpu else input_lengths.cpu() + prefix_lengths = getattr(attn_inputs, 'prefix_lengths', None) + if prefix_lengths is not None and not prefix_lengths.is_cpu: + prefix_lengths = prefix_lengths.cpu() + has_prefix = prefix_lengths is not None and prefix_lengths.numel() > 0 + # Fast path: single request, no prefix offset -> simple arange. + if input_lengths_cpu.numel() == 1 and not (has_prefix and int(prefix_lengths[0]) > 0): + return torch.arange(total_tokens, dtype=torch.long, device=device) + parts = [] + for i, slen in enumerate(input_lengths_cpu.tolist()): + offset = int(prefix_lengths[i]) if has_prefix and prefix_lengths.numel() > i else 0 + parts.append(torch.arange(offset, offset + int(slen), dtype=torch.long)) + return torch.cat(parts).to(device=device, non_blocking=True) + + +def _split_qkv_and_rope(qkv, attn_inputs, num_heads, num_kv_heads, head_dim, rope_config, need_rope, max_pos_hint=None): + """Split QKV tensor and apply RoPE. Returns q, k, v as [tokens, heads, dim].""" + total_tokens = qkv.shape[0] + q_size = num_heads * head_dim + kv_size = num_kv_heads * head_dim + + if need_rope: + positions = attn_inputs.position_ids + if positions is None: + positions = _build_prefill_positions(attn_inputs, total_tokens, qkv.device) + # Cache on attn_inputs so subsequent layers in the same forward + # pass reuse the same tensor (avoids N CPU->XPU transfers). + attn_inputs.position_ids = positions + q_flat = qkv[:, :q_size].contiguous() + k_flat = qkv[:, q_size:q_size + kv_size].contiguous() + q_flat, k_flat = _apply_rope( + q_flat, k_flat, positions, rope_config, head_dim, + num_heads, num_kv_heads, qkv.device, qkv.dtype, + max_pos_hint=max_pos_hint, + ) + q = q_flat.view(total_tokens, num_heads, head_dim) + k = k_flat.view(total_tokens, num_kv_heads, head_dim) + else: + q = qkv[:, :q_size].view(total_tokens, num_heads, head_dim) + k = qkv[:, q_size:q_size + kv_size].view(total_tokens, num_kv_heads, head_dim) + + v = qkv[:, q_size + kv_size:].view(total_tokens, num_kv_heads, head_dim) + return q, k, v + + +# ── Paged KV cache helpers ────────────────────────────────────────────── + +# Module-level LRU cache for prefill write indices. The same (bids, start_pos, +# N, tpb) recurs across all layers within one forward pass; precomputing +# device tensors once eliminates (num_layers-1) CPU->XPU transfers per request. +_PREFILL_WRITE_IDX_CACHE: OrderedDict = OrderedDict() +_PREFILL_WRITE_IDX_CACHE_MAX = 64 + + +def _get_prefill_write_indices(bids_cpu, start_pos, N, tpb, device): + """Return (block_indices_dev, offsets_dev, n_valid). Cached by + (numel, content_hash, start_pos, N, tpb, device). + """ + # Key on a full content digest (not a weak sum+last fingerprint) so a + # reallocated tensor at the same address, or two block tables that merely + # share sum/last, can never alias to a stale cached index set. + bids_contig = bids_cpu.contiguous() + content_hash = hash(bids_contig.numpy().tobytes()) + key = (bids_cpu.numel(), content_hash, + int(start_pos), int(N), int(tpb), str(device)) + cached = _PREFILL_WRITE_IDX_CACHE.get(key) + if cached is not None: + _PREFILL_WRITE_IDX_CACHE.move_to_end(key) + return cached + abs_positions = torch.arange(start_pos, start_pos + N, dtype=torch.long) + blk_slots = abs_positions // tpb + offsets_cpu = abs_positions % tpb + valid_mask = blk_slots < bids_cpu.numel() + if not valid_mask.all(): + blk_slots = blk_slots[valid_mask] + offsets_cpu = offsets_cpu[valid_mask] + n_valid = int(valid_mask.sum()) + else: + n_valid = int(N) + block_indices_cpu = bids_cpu[blk_slots].long() + block_indices_dev = block_indices_cpu.to(device, non_blocking=True) + offsets_dev = offsets_cpu.to(device, non_blocking=True) + if len(_PREFILL_WRITE_IDX_CACHE) >= _PREFILL_WRITE_IDX_CACHE_MAX: + _PREFILL_WRITE_IDX_CACHE.popitem(last=False) + val = (block_indices_dev, offsets_dev, n_valid) + _PREFILL_WRITE_IDX_CACHE[key] = val + return val + + +# Threshold above which scatter_ on a flat view beats index_put_; measured via +# tools/scatter_prototype.py. Tune per device if needed. +_SCATTER_N_THRESHOLD = 256 + + +def _flat_write_kv(cache, block_indices, offsets, k, v, tpb, H, D): + """Scatter K,V into cache[B, 2, S, H, D] via flat-view index_put_/scatter_. + + Faster than `cache[bi, 0, off, :, :] = k` because it (a) avoids the cost + of advanced-indexing two leading dims simultaneously and (b) lets the + XPU runtime emit a single linear scatter kernel. PD-safe: storage layout + unchanged. + """ + N = k.shape[0] + cache_flat = cache.view(-1, H, D) # [num_blocks*2*tpb, H, D] + # Linear index: bi * (2*tpb) + role*tpb + off + base = block_indices * (2 * tpb) + offsets + flat_idx_k = base # role=0 + flat_idx_v = base + tpb # role=1 + if N >= _SCATTER_N_THRESHOLD: + # scatter_ saturates bandwidth at large N; broadcast indices to [N,H,D] + idx_k = flat_idx_k.view(-1, 1, 1).expand(-1, H, D) + idx_v = flat_idx_v.view(-1, 1, 1).expand(-1, H, D) + cache_flat.scatter_(0, idx_k, k) + cache_flat.scatter_(0, idx_v, v) + else: + cache_flat.index_put_((flat_idx_k,), k) + cache_flat.index_put_((flat_idx_v,), v) + + +def _assert_nshd_cache(cache, tpb, num_kv_heads, head_dim): + """Validate the LayerKVCache tensor is the XPU NSHD layout this module assumes. + + Producer: KVCache::getLayerCache() in rtp_llm/models_py/bindings/OpDefs.h + (XPU branch) reshapes to [num_blocks, 2, seq_size_per_block, num_kv_heads, + head_dim]. The read/write helpers below index cache[block, k/v, seq_offset, + head, dim], so a divergent layout would silently corrupt KV. Fail loud. + """ + shape = tuple(cache.shape) + if (cache.dim() != 5 or shape[1] != 2 or shape[2] != tpb + or shape[3] != num_kv_heads or shape[4] != head_dim): + raise RuntimeError( + "XPU KV cache layout mismatch: expected NSHD " + f"[num_blocks, 2, {tpb}, {num_kv_heads}, {head_dim}] but got {shape}. " + "The producer (OpDefs.h getLayerCache XPU branch) and this consumer " + "(vllm_flash_attn paged read/write) have diverged." + ) + + +def _write_to_paged_cache(k, v, kv_cache, block_ids_cpu, start_pos, num_kv_heads, head_dim): + """Write k,v [N, kv_heads, dim] to paged LayerKVCache. + + Reuses cached device indices when the same (bids, start_pos, N) recurs + across layers in one forward pass, then dispatches to an adaptive + flat-view scatter (index_put_ at small N, scatter_ at large N). + """ + tpb = kv_cache.seq_size_per_block + cache = kv_cache.kv_cache_base # XPU flash layout: [num_blocks, 2, tpb, kv_heads, head_dim] + _assert_nshd_cache(cache, tpb, num_kv_heads, head_dim) + bids = block_ids_cpu.reshape(-1) + N = k.shape[0] + if N == 0: + return + block_indices, offsets, n_valid = _get_prefill_write_indices( + bids, start_pos, N, tpb, cache.device, + ) + if n_valid != N: + raise RuntimeError( + f"_write_to_paged_cache: block table covers only {n_valid} tokens " + f"but {N} tokens need to be written " + f"(start_pos={start_pos}, tokens_per_block={tpb}, " + f"num_blocks={bids.numel()}). " + "Ensure the block table is allocated for the full sequence length." + ) + _flat_write_kv(cache, block_indices, offsets, k, v, tpb, num_kv_heads, head_dim) + + +def _read_from_paged_cache(kv_cache, block_ids_cpu, total_len, num_kv_heads, head_dim): + """Read K,V [total_len, kv_heads, dim] from paged LayerKVCache. + + Vectorized: computes block/offset mapping for all positions at once + and gathers via advanced indexing instead of a Python while-loop. + """ + tpb = kv_cache.seq_size_per_block + cache = kv_cache.kv_cache_base # XPU flash layout: [num_blocks, 2, tpb, kv_heads, head_dim] + _assert_nshd_cache(cache, tpb, num_kv_heads, head_dim) + bids = block_ids_cpu.reshape(-1) + if total_len == 0: + return cache.new_empty(0, num_kv_heads, head_dim), cache.new_empty(0, num_kv_heads, head_dim) + # Guard against a short block table: reading total_len positions needs + # ceil(total_len / tpb) block ids. Without this check an undersized table + # would index out of bounds and silently gather garbage / wrong-request KV. + blocks_needed = (total_len + tpb - 1) // tpb + if blocks_needed > bids.numel(): + raise RuntimeError( + f"paged KV read out of range: need {blocks_needed} blocks for " + f"total_len={total_len} (tpb={tpb}) but block table has only " + f"{bids.numel()} entries." + ) + # Compute block slot and offset for each position + positions = torch.arange(total_len, dtype=torch.long) + blk_slots = positions // tpb + offsets = positions % tpb + block_indices = bids[blk_slots].long().to(cache.device) + offsets_dev = offsets.to(cache.device) + # Gather: cache[block_indices, 0/1, offsets, :, :] -> [N, kv_heads, dim] + k = cache[block_indices, 0, offsets_dev, :, :].contiguous() + v = cache[block_indices, 1, offsets_dev, :, :].contiguous() + return k, v + + +# ── Attention implementations ─────────────────────────────────────────────── + +class XpuVllmPrefillImpl(FMHAImplBase): + """Prefill: full sequence attention, stores K/V to framework\'s LayerKVCache.""" + + def __init__(self, attn_configs, attn_inputs, parallelism_config=None): + self.attn_configs = attn_configs + self.attn_inputs = attn_inputs + self.num_heads = attn_configs.head_num + self.num_kv_heads = attn_configs.kv_head_num + self.head_dim = attn_configs.size_per_head + self.rope_config = attn_configs.rope_config + self.need_rope = _need_rope(attn_configs) + self.is_causal = getattr(attn_configs, "is_causal", True) + self.fmha_params = None + # PD disaggregation: register KV blocks with cache_store after writing + self.write_cache_store_impl = common.create_write_cache_store_impl(attn_inputs) + logger.debug("[XPU PD] XpuVllmPrefillImpl init is_prefill=%s cache_store_inputs=%s write_op=%s", attn_inputs.is_prefill, bool(attn_inputs.cache_store_inputs), self.write_cache_store_impl is not None) + + @staticmethod + def support(attn_configs, attn_inputs): + if not attn_inputs.is_prefill: + return False + # XPU attention only supports BASE (unquantized) KV cache. + kv_dt = getattr(attn_configs, 'kv_cache_dtype', None) + if kv_dt is not None and kv_dt != KvCacheDataType.BASE: + raise NotImplementedError( + f"XPU prefill attention does not support quantized KV cache " + f"(got {kv_dt}). Use a non-quantized KV cache.") + # Prefix-cache (chunked prefill / reuse) is not yet implemented: + # the path does not load previously written K/V blocks into attention, + # so any request with prefix_lengths > 0 would produce wrong results. + pl = getattr(attn_inputs, 'prefix_lengths', None) + if pl is not None and pl.numel() > 0: + try: + if int(pl.sum()) > 0: + raise NotImplementedError( + "XPU prefill attention does not support prefix cache " + "(chunked prefill / KV reuse). Disable prefix cache " + "for XPU.") + except NotImplementedError: + raise + except Exception: + raise NotImplementedError( + "XPU prefill attention does not support prefix cache " + "(chunked prefill / KV reuse). Disable prefix cache " + "for XPU.") + rope_style = getattr(getattr(attn_configs, "rope_config", None), "style", RopeStyle.No) + if rope_style in _UNSUPPORTED_ROPE_STYLES: + raise NotImplementedError( + f"XPU prefill attention does not support RoPE style " + f"{rope_style}. Supported styles exclude: " + f"{_UNSUPPORTED_ROPE_STYLES}.") + return True + + def forward(self, qkv, kv_cache=None, layer_idx=0): + flash_attn_varlen = _get_flash_attn_varlen() + total_tokens = qkv.shape[0] + + input_lengths = self.attn_inputs.input_lengths + input_lengths_cpu = None + max_pos_hint = None + if input_lengths is not None and input_lengths.numel() > 0: + input_lengths_cpu = input_lengths if input_lengths.is_cpu else input_lengths.cpu() + max_pos_hint = int(input_lengths_cpu.max()) + + # Per-sequence position IDs (with prefix offsets) are derived inside + # _split_qkv_and_rope via _build_prefill_positions when position_ids + # is None. Single source of truth for KV-block id resolution. + + q, k, v = _split_qkv_and_rope( + qkv, self.attn_inputs, self.num_heads, self.num_kv_heads, + self.head_dim, self.rope_config, self.need_rope, + max_pos_hint=max_pos_hint, + ) + + # Write K,V to paged LayerKVCache for future decode steps + if kv_cache is not None: + # Prefer host block IDs to avoid device->host sync in the write path. + block_ids_all = self.attn_inputs.kv_cache_kernel_block_id + if block_ids_all is None: + block_ids_all = self.attn_inputs.kv_cache_kernel_block_id_device + if block_ids_all is None: + block_ids_all = self.attn_inputs.kv_cache_block_id + if block_ids_all is None: + block_ids_all = self.attn_inputs.kv_cache_block_id_device + if block_ids_all is None or block_ids_all.numel() == 0: + raise RuntimeError( + "XPU prefill: kv_cache is present but no block IDs available. " + "Cannot write KV to paged cache without block table.") + block_ids_cpu = block_ids_all if block_ids_all.is_cpu else block_ids_all.cpu() + if input_lengths_cpu is not None and input_lengths_cpu.numel() > 1: + # Batched prefill: write each request separately + num_reqs = input_lengths_cpu.numel() + offsets = torch.cat([torch.zeros(1, dtype=torch.int32), input_lengths_cpu.cumsum(0)]) + # block_ids_all may be [num_reqs, blocks_per_req] or [1, total_blocks] + # Reshape to [num_reqs, -1] if needed + if block_ids_cpu.dim() == 1: + blocks_per_req, _rem = divmod(block_ids_cpu.numel(), num_reqs) + if _rem != 0: + raise RuntimeError( + f"XPU batched prefill: block_ids ({block_ids_cpu.numel()}) not evenly " + f"divisible by num_reqs ({num_reqs}). Cannot reshape block table.") + bids_2d = block_ids_cpu.reshape(num_reqs, blocks_per_req) + elif block_ids_cpu.shape[0] == num_reqs: + bids_2d = block_ids_cpu + else: + blocks_per_req, _rem = divmod(block_ids_cpu.numel(), num_reqs) + if _rem != 0: + raise RuntimeError( + f"XPU batched prefill: block_ids ({block_ids_cpu.numel()}) not evenly " + f"divisible by num_reqs ({num_reqs}). Cannot reshape block table.") + bids_2d = block_ids_cpu.reshape(num_reqs, blocks_per_req) + for req_idx in range(num_reqs): + start = int(offsets[req_idx]) + end = int(offsets[req_idx + 1]) + bids = bids_2d[req_idx] + _write_to_paged_cache( + k[start:end], v[start:end], kv_cache, bids, 0, + self.num_kv_heads, self.head_dim, + ) + else: + bids = block_ids_cpu[0] + _write_to_paged_cache(k, v, kv_cache, bids, 0, + self.num_kv_heads, self.head_dim) + + # PD disaggregation: notify cache_store the KV blocks for this request + # are ready so the decode side can fetch them via P2P RPC. + if self.write_cache_store_impl is not None and layer_idx <= 1: + ai = self.attn_inputs + def _shape(t): + return None if t is None else (tuple(t.shape) if hasattr(t,"shape") else "?") + logger.debug( + "[XPU PD] write_cache_store layer=%s in_len=%s prefix_len=%s blkid_host=%s", + layer_idx, + _shape(ai.input_lengths), + _shape(ai.prefix_lengths), + _shape(ai.kv_cache_block_id), + ) + common.apply_write_cache_store( + self.write_cache_store_impl, self.attn_inputs, kv_cache + ) + + cu_seqlens_cpu = self.attn_inputs.cu_seqlens + if cu_seqlens_cpu is None or cu_seqlens_cpu.numel() <= 1: + cu_seqlens_cpu = torch.tensor([0, total_tokens], dtype=torch.int32) + + if input_lengths_cpu is not None and input_lengths_cpu.numel() > 0: + max_seqlen = int(input_lengths_cpu.max()) + else: + max_seqlen = int((cu_seqlens_cpu[1:] - cu_seqlens_cpu[:-1]).max()) + + cu_seqlens = cu_seqlens_cpu.to(device=qkv.device, dtype=torch.int32) + output = flash_attn_varlen( + q.contiguous(), k.contiguous(), v.contiguous(), + cu_seqlens_q=cu_seqlens, cu_seqlens_k=cu_seqlens, + max_seqlen_q=max_seqlen, max_seqlen_k=max_seqlen, + causal=self.is_causal, + ) + return output.reshape(total_tokens, -1) + + +class XpuVllmDecodeImpl(FMHAImplBase): + """Decode: process new token(s), read K/V from framework\'s LayerKVCache. + + Supports batched decode with multiple requests. Uses flash_attn_varlen + with per-request cu_seqlens to handle different KV lengths. + """ + + # --- Decode KV gather scratch: capacity cap + release policy --- + # The gather scratch is retained per (device, stream) to avoid per-layer + # allocations. To bound steady-state memory: never retain a buffer larger + # than _SCRATCH_RETAIN_MAX_BYTES (a long-context request above the cap uses + # a transient buffer freed after the step), and keep at most + # _SCRATCH_MAX_STREAMS retained entries. reset_decode_scratch() drops all. + _SCRATCH_RETAIN_MAX_BYTES = int( + os.environ.get("XPU_DECODE_SCRATCH_MAX_MB", "512")) * 1024 * 1024 + _SCRATCH_MAX_STREAMS = 8 + + @classmethod + def reset_decode_scratch(cls): + """Drop all retained decode KV scratch buffers (release policy hook).""" + cls._kv_scratch_by_stream = {} + cls._flat_bids_cache = None + cls._write_idx_cache = None + cls._pos_ids_cache = None + cls._seqused_k_cache = None + cls._last_layer_idx = None + + def __init__(self, attn_configs, attn_inputs, parallelism_config=None): + self.attn_configs = attn_configs + self.attn_inputs = attn_inputs + self.num_heads = attn_configs.head_num + self.num_kv_heads = attn_configs.kv_head_num + self.head_dim = attn_configs.size_per_head + self.rope_config = attn_configs.rope_config + self.need_rope = _need_rope(attn_configs) + self.fmha_params = None + + @staticmethod + def support(attn_configs, attn_inputs): + if attn_inputs.is_prefill: + return False + # XPU attention only supports BASE (unquantized) KV cache. + kv_dt = getattr(attn_configs, 'kv_cache_dtype', None) + if kv_dt is not None and kv_dt != KvCacheDataType.BASE: + raise NotImplementedError( + f"XPU decode attention does not support quantized KV cache " + f"(got {kv_dt}). Use a non-quantized KV cache.") + # Requires FA2 (flash_attn_varlen). When FA2 is not installed + # no XPU decode impl supports this config. + if not _is_fa2_available(): + raise NotImplementedError( + "XPU decode attention requires flash_attn (FA2) but it is " + "not installed. Install vllm-xpu-kernels with FA2 support.") + rope_style = getattr(getattr(attn_configs, "rope_config", None), "style", RopeStyle.No) + if rope_style in _UNSUPPORTED_ROPE_STYLES: + raise NotImplementedError( + f"XPU decode attention does not support RoPE style " + f"{rope_style}. Supported styles exclude: " + f"{_UNSUPPORTED_ROPE_STYLES}.") + return True + + def forward(self, qkv, kv_cache=None, layer_idx=0): + if kv_cache is not None: + return self._paged_decode(qkv, kv_cache, layer_idx) + # No paged cache: a decode step needs the KV history, and RoPE here would + # use default arange(N) positions (wrong for decode, where each token's + # position is its absolute sequence index). Fail fast rather than emit + # silently-wrong output; the no-RoPE case can still self-attend. + if self.need_rope: + raise NotImplementedError( + "XpuVllmDecodeImpl requires a paged kv_cache for RoPE decode; " + "the no-kv-cache fallback would use incorrect RoPE positions.") + # Fallback: no paged cache, self-attend over current tokens + flash_attn_varlen = _get_flash_attn_varlen() + q, k, v = _split_qkv_and_rope( + qkv, self.attn_inputs, self.num_heads, self.num_kv_heads, + self.head_dim, self.rope_config, self.need_rope, + ) + N = qkv.shape[0] + cu = torch.tensor([0, N], dtype=torch.int32, device=qkv.device) + output = flash_attn_varlen(q, k, v, cu_seqlens_q=cu, cu_seqlens_k=cu, + max_seqlen_q=N, max_seqlen_k=N, causal=True) + return output.reshape(N, -1) + + def _paged_decode(self, qkv, kv_cache, layer_idx): + """Decode using paged LayerKVCache with block_table support. + + Optimized: uses CPU-side metadata to avoid GPU→CPU syncs, passes + block_table directly to flash_attn_varlen without unique/remap. + """ + flash_attn_varlen = _get_flash_attn_varlen() + seq_lengths = self.attn_inputs.sequence_lengths + if seq_lengths is None: + raise RuntimeError("XPU paged decode requires sequence_lengths") + + # Guard against speculative/multi-token decode (q_len > 1 per request). + # This path assumes max_seqlen_q=1 (normal autoregressive decode). + _num_req = seq_lengths.numel() + if qkv.shape[0] != _num_req: + raise NotImplementedError( + f"XPU paged decode does not support multi-token query " + f"(got {qkv.shape[0]} tokens for {_num_req} requests). " + f"Speculative decode is not supported on XPU." + ) + + # --- Use CPU-side block IDs to avoid device→host sync --- + # Prefer kernel-granularity block IDs for attention compute; + # fall back to physical block IDs (identical when kernel_blocks_per_kv_block == 1). + block_ids_host = self.attn_inputs.kv_cache_kernel_block_id + if block_ids_host is None: + block_ids_host = self.attn_inputs.kv_cache_block_id + block_ids_device = self.attn_inputs.kv_cache_kernel_block_id_device + if block_ids_device is None: + block_ids_device = self.attn_inputs.kv_cache_block_id_device + + num_requests = seq_lengths.numel() + + # --- Keep seq_lengths on CPU; avoid GPU→CPU sync --- + seq_lens_cpu = seq_lengths if seq_lengths.is_cpu else seq_lengths.cpu() + + # Compute max position on CPU (no GPU sync) for RoPE cache sizing + max_pos_hint = int(seq_lens_cpu.max()) if seq_lens_cpu.numel() > 0 else 0 + + # Class-level step caches (shared across all layers in one decode step). + cls = type(self) + # Step counter: increments exactly once per decode step (not per layer). + # Derive the step boundary from the authoritative layer_idx sequence + # (each decode step calls layers 0, 1, ..., num_layers-1 in order) + # rather than from a seq_lens content fingerprint. When layer_idx wraps + # back (current <= last seen) a new decode step has begun, so _step_id is + # bumped. This guarantees every step gets a unique, monotonically + # increasing id, so the per-step device tensors cached below + # (position_ids / write indices / flat_bids / seqused_k) can never be + # reused across two different batch shapes that merely share the same + # seq_lens fingerprint. + _last_layer = getattr(cls, "_last_layer_idx", None) + _is_step_start = (_last_layer is None or layer_idx <= _last_layer) + if _is_step_start: + cls._step_id = getattr(cls, "_step_id", 0) + 1 + cls._last_layer_idx = layer_idx + _sid = cls._step_id + # Content-address every per-step device cache so concurrent decode on + # different XPU streams (or a _step_id collision under interleaving) + # cannot produce a false hit: keys carry the current stream plus a full + # content fingerprint of seq_lens, making each cached value a pure + # function of its inputs (a stale key is a correct miss, never a wrong + # reuse). + try: + _stream_key = torch.xpu.current_stream(qkv.device) + except Exception: + _stream_key = None + if _is_step_start: + cls._step_seq_fp = hash(seq_lens_cpu.contiguous().numpy().tobytes()) + _seq_fp = cls._step_seq_fp + # Set position_ids for RoPE — CPU→device transfer (async, no sync). + # Hoist across layers: identical for all 36 layers in a decode step. + if self.need_rope: + _pid_key = ( + _sid, + _stream_key, + _seq_fp, + qkv.device, + ) + _pid_cache = getattr(cls, "_pos_ids_cache", None) + if _pid_cache is not None and _pid_cache[0] == _pid_key: + self.attn_inputs.position_ids = _pid_cache[1] + else: + _pid = seq_lens_cpu.to(dtype=torch.long, device=qkv.device, non_blocking=True) + cls._pos_ids_cache = (_pid_key, _pid) + self.attn_inputs.position_ids = _pid + + q_new, k_new, v_new = _split_qkv_and_rope( + qkv, self.attn_inputs, self.num_heads, self.num_kv_heads, + self.head_dim, self.rope_config, self.need_rope, + max_pos_hint=max_pos_hint, + ) + + cache = kv_cache.kv_cache_base + tpb = kv_cache.seq_size_per_block + _assert_nshd_cache(cache, tpb, self.num_kv_heads, self.head_dim) + + # --- Resolve block IDs on CPU without GPU sync --- + # TODO(xpu): hybrid KV (GLA/sliding window) uses per-group block + # tables (kv_cache_block_id varies by cache group). Currently we use + # a single block table for all layers. When hybrid models are needed, + # select the correct 2D table via kv_cache_layer_to_group[layer_idx]. + if block_ids_host is not None: + bids_2d_cpu = block_ids_host.reshape(num_requests, -1) + elif block_ids_device is not None: + bids_2d_cpu = block_ids_device.reshape(num_requests, -1).cpu() + else: + raise RuntimeError("No block IDs available for paged decode") + + # --- Vectorized K,V writes for new decode tokens --- + # Cache layout: [num_blocks, 2, tpb, kv_heads, head_dim] (XPU flash layout) + kv_lens = seq_lens_cpu + 1 # CPU tensor + n_blocks_per_req = (kv_lens + tpb - 1) // tpb # CPU tensor + max_blocks_needed = int(n_blocks_per_req.max()) + needed_bids = bids_2d_cpu[:, :max_blocks_needed] + + # Block-table content fingerprint. Within one decode step all layers of + # a homogeneous model share the same table, so hashing once at step + # start and reusing it lets the per-step device caches below hit across + # all layers. + # + # TODO(xpu): make this hash per-layer/per-group before enabling hybrid + # models. The hash is computed ONLY at _is_step_start (layer wrap-around) + # and reused for every later layer. A hybrid model (GLA/sliding-window) + # whose layers map to different cache groups has per-group block tables, + # but later layers would still key off layer-0's STALE hash -> the + # write_idx_cache / flat_bids_cache would falsely HIT and use the wrong + # block indices. Safe today only because XPU has no hybrid-model support + # (single block table for all layers, see the bids_2d_cpu TODO above). + if _is_step_start: + cls._step_table_hash = hash(needed_bids.contiguous().numpy().tobytes()) + _table_hash = cls._step_table_hash + + # Hoist write-indices CPU→GPU across layers (identical for all 36 layers) + _wk = (_sid, _stream_key, _table_hash, _seq_fp, cache.device) + _wc = getattr(cls, "_write_idx_cache", None) + if _wc is not None and _wc[0] == _wk: + bid_dev, off_dev = _wc[1], _wc[2] + else: + write_positions = seq_lens_cpu.long() + blk_slots_cpu = write_positions // tpb + offsets_cpu = (write_positions % tpb).long() + bid_indices = torch.tensor( + [int(bids_2d_cpu[i, int(blk_slots_cpu[i])]) for i in range(num_requests)], + dtype=torch.long, + ) + bid_dev = bid_indices.to(cache.device, non_blocking=True) + off_dev = offsets_cpu.to(cache.device, non_blocking=True) + cls._write_idx_cache = (_wk, bid_dev, off_dev) + + # Two kernel launches total (vs 2 * num_requests in the per-loop write). + cache[bid_dev, 0, off_dev, :, :] = k_new + cache[bid_dev, 1, off_dev, :, :] = v_new + + # --- Gather active blocks into contiguous K/V buffers --- + # cache[:, 0] / cache[:, 1] are non-contiguous slices (stride 2 along + # block axis). flash_attn requires contiguous K and V, so we gather + # the active blocks via index_select. With the flash layout + # [num_blocks, 2, tpb, H, D] the gather output is already + # [Nb, tpb, H, D] -- no transpose needed (the legacy MHA layout + # required an extra transpose copy). + # TODO(xpu perf, tracked): this gather copies the full active KV history + # every layer x every decode step. The decode FA2 path already accepts + # a block_table, so the only thing forcing the copy is the interleaved + # [num_blocks, 2, tpb, H, D] layout (cache[:, 0]/cache[:, 1] are strided + # and FA2 needs contiguous paged K/V). Splitting the cache to + # [2, num_blocks, tpb, H, D] makes cache[0]/cache[1] contiguous paged + # tensors, letting us pass them + the real `needed_bids` block_table + # directly and delete this gather + scratch entirely. Deferred: it is a + # KV-layout migration that must move in lockstep with the C++ cache + # allocator, the prefill write path, and the PD cache-store transfer, + # and requires full PD accuracy + perf re-validation. + # Cache key includes the block-table fingerprint so a hybrid model + # whose layers belong to different cache groups cannot reuse another + # group's flat_bids within the same step. _sid guards cross-step reuse; + # for homogeneous models every layer shares one table -> still a hit. + _fb_key = (_sid, _stream_key, _table_hash, cache.device) + _fb_cache = getattr(cls, "_flat_bids_cache", None) + if _fb_cache is not None and _fb_cache[0] == _fb_key: + flat_bids = _fb_cache[1] + else: + flat_bids = needed_bids.reshape(-1).long().to(cache.device, non_blocking=True) + cls._flat_bids_cache = (_fb_key, flat_bids) + nb = flat_bids.numel() + H = self.num_kv_heads + D = self.head_dim + need_size = nb * tpb * H * D + # Scratch is bounded by total KV cache capacity; assert to make bound explicit. + max_allowed = cache.shape[0] * tpb * H * D + if need_size > max_allowed: + raise RuntimeError( + f"KV scratch {need_size} exceeds cache capacity {max_allowed}") + # Persistent scratch buffers grow monotonically to avoid per-call + # XPU allocations across N layers x M steps. Scratch is keyed by + # (device, current stream): kernels submitted to one XPU stream are + # serialized, so a buffer is safe to reuse across the N layers of a + # single decode step on that stream. Keying by stream isolates + # concurrent decode batches running on different streams instead of + # sharing one class-level buffer. + scratch_map = getattr(cls, "_kv_scratch_by_stream", None) + if scratch_map is None: + scratch_map = {} + cls._kv_scratch_by_stream = scratch_map + key = (cache.device, _stream_key) + mk = lambda: torch.empty(need_size, dtype=cache.dtype, device=cache.device) + # A retained entry holds TWO buffers (K and V), so the memory actually + # retained per key is 2 * need_bytes. Compare that total against the cap + # so XPU_DECODE_SCRATCH_MAX_MB reflects real retained bytes, not half. + need_bytes = 2 * need_size * cache.element_size() + if need_bytes > cls._SCRATCH_RETAIN_MAX_BYTES: + # Above the retention cap: use transient buffers (freed after this + # step) so a single long-context request cannot permanently inflate + # the retained scratch. Drop any retained entry for this key. + scratch_map.pop(key, None) + scratch = (mk(), mk()) + else: + scratch = scratch_map.get(key) + if scratch is None or scratch[0].dtype != cache.dtype or \ + scratch[0].numel() < need_size: + # Bound the number of retained per-stream buffers (evict oldest). + if key not in scratch_map and len(scratch_map) >= cls._SCRATCH_MAX_STREAMS: + scratch_map.pop(next(iter(scratch_map))) + scratch = (mk(), mk()) + scratch_map[key] = scratch + k_cache = scratch[0][:need_size].view(nb, tpb, H, D) + v_cache = scratch[1][:need_size].view(nb, tpb, H, D) + torch.index_select(cache[:, 0], 0, flat_bids, out=k_cache) + torch.index_select(cache[:, 1], 0, flat_bids, out=v_cache) + + # Sequential block_table: blocks gathered in order. + block_table = _get_arange( + flat_bids.numel(), torch.int32, qkv.device, + ).reshape(num_requests, max_blocks_needed) + + max_kv_len = int(kv_lens.max()) # CPU tensor, no GPU sync + # Hoist seqused_k across layers: kv_lens identical for all layers + # in one decode step. Saves N-1 CPU->XPU copies per step. + _sk_key = ( + _sid, + _stream_key, + _table_hash, + kv_lens.numel(), + _seq_fp, + qkv.device, + ) + _sk_cache = getattr(cls, "_seqused_k_cache", None) + if _sk_cache is not None and _sk_cache[0] == _sk_key: + seqused_k = _sk_cache[1] + else: + seqused_k = kv_lens.to(dtype=torch.int32, device=qkv.device, non_blocking=True) + cls._seqused_k_cache = (_sk_key, seqused_k) + cu_q = _get_arange(num_requests + 1, torch.int32, qkv.device) + + output = flash_attn_varlen( + q_new.contiguous(), + k_cache, + v_cache, + cu_seqlens_q=cu_q, + cu_seqlens_k=None, + max_seqlen_q=1, + max_seqlen_k=max_kv_len, + causal=False, + block_table=block_table, + seqused_k=seqused_k, + ) + return output.reshape(num_requests, -1) + +# Aliases for upstream compatibility +XpuVllmFlashAttnPrefillImpl = XpuVllmPrefillImpl +XpuVllmFlashAttnDecodeImpl = XpuVllmDecodeImpl diff --git a/rtp_llm/models_py/modules/factory/fused_moe/__init__.py b/rtp_llm/models_py/modules/factory/fused_moe/__init__.py index a5f0ff05fe..5651bc3603 100644 --- a/rtp_llm/models_py/modules/factory/fused_moe/__init__.py +++ b/rtp_llm/models_py/modules/factory/fused_moe/__init__.py @@ -39,7 +39,14 @@ BatchedTritonStrategy, ) -if device_type == DeviceType.ROCm: +if device_type == DeviceType.Xpu: + # ========== XPU Registry ========== + # XPU: no custom MOE kernels yet. Use common batched triton strategy only. + registry = StrategyRegistry() + registry.register(BatchedTritonStrategy()) + FusedMoeFactory.set_registry(registry) + +elif device_type == DeviceType.ROCm: # ========== ROCm Registry ========== # MoE strategies diff --git a/rtp_llm/models_py/modules/factory/fused_moe/impl/xpu/__init__.py b/rtp_llm/models_py/modules/factory/fused_moe/impl/xpu/__init__.py new file mode 100644 index 0000000000..beed143772 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/fused_moe/impl/xpu/__init__.py @@ -0,0 +1,5 @@ +"""XPU MOE implementations placeholder. + +Initial XPU enablement does not include custom MOE kernels. +Uses the common batched triton strategy as fallback. +""" diff --git a/rtp_llm/models_py/modules/factory/linear/__init__.py b/rtp_llm/models_py/modules/factory/linear/__init__.py index aa7b906d6d..a1c92ed2e4 100644 --- a/rtp_llm/models_py/modules/factory/linear/__init__.py +++ b/rtp_llm/models_py/modules/factory/linear/__init__.py @@ -18,7 +18,10 @@ device_type = get_device_type() try: - if device_type == DeviceType.ROCm: + if device_type == DeviceType.Xpu: + # Import to trigger XPU Linear strategy registration + import rtp_llm.models_py.modules.factory.linear.impl.xpu # noqa: F401 + elif device_type == DeviceType.ROCm: # Import to trigger ROCm Linear strategy registration import rtp_llm.models_py.modules.factory.linear.impl.rocm # noqa: F401 else: diff --git a/rtp_llm/models_py/modules/factory/linear/impl/xpu/__init__.py b/rtp_llm/models_py/modules/factory/linear/impl/xpu/__init__.py new file mode 100644 index 0000000000..e5ebd3b8c4 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/linear/impl/xpu/__init__.py @@ -0,0 +1,14 @@ +"""XPU Linear implementations and registration. + +Uses PyTorch F.linear for all computations on Intel XPU. +""" + +import logging + +logger = logging.getLogger(__name__) +logger.debug("Registered XPU Linear strategies") + +from rtp_llm.models_py.modules.factory.linear.factory import LinearFactory +from .f16_linear import XpuF16Linear + +LinearFactory.register(XpuF16Linear) diff --git a/rtp_llm/models_py/modules/factory/linear/impl/xpu/f16_linear.py b/rtp_llm/models_py/modules/factory/linear/impl/xpu/f16_linear.py new file mode 100644 index 0000000000..8d56fc4743 --- /dev/null +++ b/rtp_llm/models_py/modules/factory/linear/impl/xpu/f16_linear.py @@ -0,0 +1,53 @@ +"""XPU F16/BF16 (non-quantized) Linear implementation. + +Uses PyTorch F.linear on Intel XPU. Identical to the CUDA F16 implementation +since PyTorch handles device dispatch internally. +""" + +from typing import Optional + +import torch +from torch.nn import functional as F + +from rtp_llm.models_py.modules.factory.linear import LinearBase +from rtp_llm.ops import HWKernelConfig + + +class XpuF16Linear(LinearBase): + """XPU F16/BF16 (non-quantized) Linear using PyTorch ops.""" + + @classmethod + def can_handle( + cls, + quant_config: object, + weight: torch.Tensor, + weight_scales: Optional[torch.Tensor], + hw_kernel_config: Optional['HWKernelConfig'] = None, + weight_scale_2: Optional[torch.Tensor] = None, + input_scale: Optional[torch.Tensor] = None, + ) -> bool: + """Handle non-quantized weights (weight_scales is None), matching the + CUDA F16Linear contract. A model-level quant_config does not by itself + make a given weight quantized; whether a quantized weight is handled is + decided by weight_scales / the specific quant strategy, so gating on a + non-empty quant_config here would starve unquantized layers (lm_head, + unquantized blocks) of any candidate strategy. + """ + return weight_scales is None + + def __init__( + self, + weight: torch.Tensor, + weight_scales: Optional[torch.Tensor] = None, + input_scales: Optional[torch.Tensor] = None, + bias: Optional[torch.Tensor] = None, + quant_config: object = None, + weight_scale_2: Optional[torch.Tensor] = None, + ): + super().__init__(weight, weight_scales, input_scales, + bias, quant_config, weight_scale_2) + self.weight = weight.T + self.bias = bias + + def forward(self, input: torch.Tensor) -> torch.Tensor: + return F.linear(input, self.weight, self.bias) diff --git a/rtp_llm/models_py/modules/hybrid/causal_attention.py b/rtp_llm/models_py/modules/hybrid/causal_attention.py index 2d681da6e6..48fdfeda76 100644 --- a/rtp_llm/models_py/modules/hybrid/causal_attention.py +++ b/rtp_llm/models_py/modules/hybrid/causal_attention.py @@ -15,6 +15,8 @@ device_type = get_device_type() if device_type == DeviceType.ROCm: from rtp_llm.models_py.modules.base.rocm.norm import FusedQKRMSNorm +elif device_type == DeviceType.Xpu: + from rtp_llm.models_py.modules.base.xpu.norm import FusedQKRMSNorm else: from rtp_llm.models_py.modules.base.cuda.norm import FusedQKRMSNorm diff --git a/rtp_llm/models_py/standalone/auto_model.py b/rtp_llm/models_py/standalone/auto_model.py index 44ec202590..f72981f9d2 100644 --- a/rtp_llm/models_py/standalone/auto_model.py +++ b/rtp_llm/models_py/standalone/auto_model.py @@ -68,6 +68,29 @@ def __init__( model_config=model_config, ) + # XPU only supports MHA attention (initRuntime forces MlaOpsType::MHA). + # The runtime is initialized after the model is built, so its resolved + # type would arrive too late; pin MHA here so MLA/DeepSeek models are + # constructed with the attention type the XPU runtime will actually use. + from rtp_llm.device.device_impl import _is_xpu_device + if _is_xpu_device(): + from rtp_llm.ops import MlaOpsType + if model_config.mla_ops_type != MlaOpsType.MHA: + logging.info( + "XPU only supports MHA; overriding mla_ops_type %s -> MHA", + model_config.mla_ops_type) + model_config.mla_ops_type = MlaOpsType.MHA + + # Bind the current process to its target GPU BEFORE creating/loading + # the model. Otherwise model weights default to device 0 while the C++ + # runtime (init_exec_ctx below) binds to world_rank % local_world_size, + # so on multi-GPU nodes Python weights and the runtime land on different + # devices. + pc = engine_config.parallelism_config + device_id = pc.world_rank % pc.local_world_size + from rtp_llm.device.device_impl import gpu_set_device + gpu_set_device(device_id) + # Create model using ModelFactory self.gpt_model = ModelFactory._create_model( model_config=model_config, @@ -82,14 +105,14 @@ def __init__( self.model = self.gpt_model.py_model self.model_config = self.gpt_model.model_config - pc = engine_config.parallelism_config init_exec_ctx( - device_id=pc.world_rank % pc.local_world_size, + device_id=device_id, trace_memory=engine_config.profiling_debug_logging_config.trace_memory, enable_comm_overlap=engine_config.device_resource_config.enable_comm_overlap, mla_ops_type=int(model_config.mla_ops_type), ) - self.device = "cuda" + from rtp_llm.device.device_impl import get_device_string + self.device = get_device_string() # init kv cache and bind it to py model self.tokens_per_block = self.model_config.attn_config.tokens_per_block @@ -140,13 +163,20 @@ def _init_kv_cache(self): CacheGroupType.FULL for _ in range(self.layer_num) ] - per_layer_shape = [ - self.block_nums, - 2, - self.kv_head_num, - self.tokens_per_block, - self.size_per_head, - ] + # KV cache layout differs by device: + # CUDA/ROCm: [num_blocks, 2, kv_heads, tokens_per_block, head_dim] + # XPU: [num_blocks, 2, tokens_per_block, kv_heads, head_dim] + from rtp_llm.device.device_impl import _is_xpu_device + if _is_xpu_device(): + per_layer_shape = [ + self.block_nums, 2, + self.tokens_per_block, self.kv_head_num, self.size_per_head, + ] + else: + per_layer_shape = [ + self.block_nums, 2, + self.kv_head_num, self.tokens_per_block, self.size_per_head, + ] self.kv_cache.kv_cache_base_by_layer = [ torch.zeros(per_layer_shape, dtype=self.compute_dtype, device=self.device) for _ in range(self.layer_num) @@ -202,7 +232,9 @@ def _prepare_decode_attention_inputs( # sequence_lengths is index, so minus 1 attention_inputs.sequence_lengths = torch.tensor( [sequence_length - 1], dtype=torch.int32 - ).pin_memory() + ) + if self.device == "cuda": + attention_inputs.sequence_lengths = attention_inputs.sequence_lengths.pin_memory() attention_inputs.kv_cache_block_id_device = torch.tensor( [[i for i in range(1, need_block_nums + 1)]], dtype=torch.int32, diff --git a/rtp_llm/models_py/utils/arch.py b/rtp_llm/models_py/utils/arch.py index b7c934db1c..a686daa164 100644 --- a/rtp_llm/models_py/utils/arch.py +++ b/rtp_llm/models_py/utils/arch.py @@ -2,7 +2,7 @@ import torch -from rtp_llm.device.device_type import DeviceType, get_device_type, is_cuda, is_hip +from rtp_llm.device.device_type import DeviceType, get_device_type, is_cuda, is_hip, is_xpu def get_num_device_sms() -> int: @@ -16,5 +16,7 @@ def get_num_device_sms() -> int: def get_sm(device_id: int = 0) -> Tuple[int, int]: + if not is_cuda(): + raise NotImplementedError("get_sm() is only supported on CUDA devices") major, minor = torch.cuda.get_device_capability(device_id) return major, minor diff --git a/rtp_llm/ops/__init__.py b/rtp_llm/ops/__init__.py index 32c96be5f1..ffe19fa91c 100644 --- a/rtp_llm/ops/__init__.py +++ b/rtp_llm/ops/__init__.py @@ -102,6 +102,8 @@ def find_th_transformer(current_dir: str): logging.info(f"Exception: {e}, traceback: {traceback.format_exc()}") # frontend cannot load libpython3.10.so, so we need to load it manually +# In XPU env, we keep libpython3.10.so hardcoded and explicitly link it +# to the actual Python runtime library. import sysconfig from ctypes import cdll diff --git a/rtp_llm/start_backend_server.py b/rtp_llm/start_backend_server.py index 6e9fbf2bc0..232a01e00b 100644 --- a/rtp_llm/start_backend_server.py +++ b/rtp_llm/start_backend_server.py @@ -12,6 +12,12 @@ from typing import List, Optional import torch +from rtp_llm.device.device_impl import ( + gpu_is_available, + gpu_device_count, + get_visible_device_list, + _is_xpu_device, +) from setproctitle import setproctitle CUR_PATH = os.path.dirname(os.path.abspath(__file__)) @@ -117,7 +123,7 @@ def signal_handler(signum, frame): def _get_local_world_size(py_env_configs: PyEnvConfigs) -> int: """Calculate local world size based on environment and hardware""" world_size = py_env_configs.parallelism_config.world_size - local_world_size = min(torch.cuda.device_count(), world_size) + local_world_size = min(gpu_device_count(), world_size) if "LOCAL_WORLD_SIZE" in os.environ: logging.info( f"multi rank starts with local world size specified in env: {os.environ['LOCAL_WORLD_SIZE']}" @@ -126,20 +132,15 @@ def _get_local_world_size(py_env_configs: PyEnvConfigs) -> int: else: logging.info( f"multi rank starts with default local world size: {local_world_size}, " - f"device count = {torch.cuda.device_count()}, world size = {world_size}" + f"device count = {gpu_device_count()}, world size = {world_size}" ) os.environ["LOCAL_WORLD_SIZE"] = str(local_world_size) return local_world_size def _get_cuda_device_list() -> List[str]: - """Get CUDA device list from environment or hardware detection""" - cuda_devices = os.environ.get("CUDA_VISIBLE_DEVICES", None) - return ( - cuda_devices.split(",") - if cuda_devices is not None - else [str(i) for i in range(torch.cuda.device_count())] - ) + """Get GPU device list from environment or hardware detection""" + return get_visible_device_list() def _validate_dp_configuration(py_env_configs: PyEnvConfigs): @@ -167,7 +168,14 @@ def _create_rank_processes( range(pc.world_rank, pc.world_rank + local_world_size) ): reader, writer = multiprocessing.Pipe(duplex=False) - os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(cuda_device_list) + # Bind visible devices using the env var that matches the runtime: + # XPU honors ZE_AFFINITY_MASK, CUDA/ROCm honor CUDA_VISIBLE_DEVICES. + # (Per-rank device pinning itself happens in the child via + # setup_cuda_device_and_accl_env -> torch.{xpu,cuda}.set_device.) + if _is_xpu_device(): + os.environ["ZE_AFFINITY_MASK"] = ",".join(cuda_device_list) + else: + os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(cuda_device_list) os.environ["WORLD_RANK"] = str(world_rank) proc = Process( @@ -425,20 +433,40 @@ def start_backend_server( clear_jit_filelock() - if not torch.cuda.is_available(): + if not gpu_is_available(): return local_rank_start(global_controller, py_env_configs) pc = py_env_configs.parallelism_config + + # XPU multi-rank requires oneCCL/xccl distributed backend. + # Fail-fast when world_size>1 on XPU until DP/PP paths are validated. + if _is_xpu_device() and pc.world_size > 1: + raise RuntimeError( + f"XPU multi-rank startup (world_size={pc.world_size}, " + f"device_count={gpu_device_count()}) is not supported yet. " + "Run with world_size=1." + ) + + # Guard against a 0-device backend (e.g. RTP_LLM_DEVICE_TYPE override points + # at a backend with no visible devices) before using gpu_device_count() as a + # divisor below. + if gpu_device_count() == 0: + raise RuntimeError( + "No usable GPU devices found for the resolved device type. Check " + "RTP_LLM_DEVICE_TYPE and the visible-device mask " + "(CUDA_VISIBLE_DEVICES/ZE_AFFINITY_MASK)." + ) + if ( - pc.world_size % torch.cuda.device_count() != 0 - and pc.world_size > torch.cuda.device_count() + pc.world_size % gpu_device_count() != 0 + and pc.world_size > gpu_device_count() ): raise Exception( - f"result: {pc.world_size % torch.cuda.device_count()} \ - not support WORLD_SIZE {pc.world_size} for {torch.cuda.device_count()} local gpu" + f"result: {pc.world_size % gpu_device_count()} \ + not support WORLD_SIZE {pc.world_size} for {gpu_device_count()} local gpu" ) - if torch.cuda.device_count() > 1 and pc.world_size > 1: + if gpu_device_count() > 1 and pc.world_size > 1: return multi_rank_start(global_controller, py_env_configs, pipe_writer) else: return local_rank_start(global_controller, py_env_configs, 0, pipe_writer)