From 0ce414f7c939d36312f44bc2209f12f32fd663a8 Mon Sep 17 00:00:00 2001 From: yungYEEZY <259074499+yungYEEZY@users.noreply.github.com> Date: Sun, 5 Apr 2026 08:22:33 +0200 Subject: [PATCH] Fix for human-parser-comfyui-node Torch 2.11 Compatibility The `human-parser-comfyui-node` uses the `inplace_abn` library which contains deprecated PyTorch C++ API calls that were removed in PyTorch 2.11. --- schp/modules/src/checks.h | 11 ++--- schp/modules/src/inplace_abn.cpp | 10 ++-- schp/modules/src/inplace_abn_cpu.cpp | 12 ++--- schp/modules/src/inplace_abn_cpu_only.cpp | 10 ++-- schp/modules/src/inplace_abn_cuda.cu | 60 +++++++++++------------ schp/modules/src/inplace_abn_cuda_half.cu | 48 +++++++++--------- schp/modules/src/utils/checks.h | 6 +-- 7 files changed, 76 insertions(+), 81 deletions(-) diff --git a/schp/modules/src/checks.h b/schp/modules/src/checks.h index e761a6f..49360fb 100644 --- a/schp/modules/src/checks.h +++ b/schp/modules/src/checks.h @@ -2,14 +2,9 @@ #include -// Define AT_CHECK for old version of ATen where the same function was called AT_ASSERT -#ifndef AT_CHECK -#define AT_CHECK AT_ASSERT -#endif - -#define CHECK_CUDA(x) AT_CHECK((x).type().is_cuda(), #x " must be a CUDA tensor") -#define CHECK_CPU(x) AT_CHECK(!(x).type().is_cuda(), #x " must be a CPU tensor") -#define CHECK_CONTIGUOUS(x) AT_CHECK((x).is_contiguous(), #x " must be contiguous") +#define CHECK_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_CONTIGUOUS(x) TORCH_CHECK((x).is_contiguous(), #x " must be contiguous") #define CHECK_CUDA_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x) #define CHECK_CPU_INPUT(x) CHECK_CPU(x); CHECK_CONTIGUOUS(x) \ No newline at end of file diff --git a/schp/modules/src/inplace_abn.cpp b/schp/modules/src/inplace_abn.cpp index 633ca6f..bbc671a 100644 --- a/schp/modules/src/inplace_abn.cpp +++ b/schp/modules/src/inplace_abn.cpp @@ -8,7 +8,7 @@ std::vector mean_var(at::Tensor x) { if (x.is_cuda()) { - if (x.type().scalarType() == at::ScalarType::Half) + if (x.scalar_type() == at::ScalarType::Half) { return mean_var_cuda_h(x); } @@ -28,7 +28,7 @@ at::Tensor forward(at::Tensor x, at::Tensor mean, at::Tensor var, at::Tensor wei { if (x.is_cuda()) { - if (x.type().scalarType() == at::ScalarType::Half) + if (x.scalar_type() == at::ScalarType::Half) { return forward_cuda_h(x, mean, var, weight, bias, affine, eps); } @@ -48,7 +48,7 @@ std::vector edz_eydz(at::Tensor z, at::Tensor dz, at::Tensor weight, { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return edz_eydz_cuda_h(z, dz, weight, bias, affine, eps); } @@ -68,7 +68,7 @@ at::Tensor backward(at::Tensor z, at::Tensor dz, at::Tensor var, at::Tensor weig { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return backward_cuda_h(z, dz, var, weight, bias, edz, eydz, affine, eps); } @@ -92,7 +92,7 @@ void leaky_relu_backward(at::Tensor z, at::Tensor dz, float slope) { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return leaky_relu_backward_cuda_h(z, dz, slope); } diff --git a/schp/modules/src/inplace_abn_cpu.cpp b/schp/modules/src/inplace_abn_cpu.cpp index ffc6d38..1bd5441 100644 --- a/schp/modules/src/inplace_abn_cpu.cpp +++ b/schp/modules/src/inplace_abn_cpu.cpp @@ -86,10 +86,10 @@ void leaky_relu_backward_cpu(at::Tensor z, at::Tensor dz, float slope) { CHECK_CPU_INPUT(z); CHECK_CPU_INPUT(dz); - AT_DISPATCH_FLOATING_TYPES(z.type(), "leaky_relu_backward_cpu", ([&] { + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "leaky_relu_backward_cpu", ([&] { int64_t count = z.numel(); - auto *_z = z.data(); - auto *_dz = dz.data(); + auto *_z = z.data_ptr(); + auto *_dz = dz.data_ptr(); for (int64_t i = 0; i < count; ++i) { if (_z[i] < 0) { @@ -104,10 +104,10 @@ void elu_backward_cpu(at::Tensor z, at::Tensor dz) { CHECK_CPU_INPUT(z); CHECK_CPU_INPUT(dz); - AT_DISPATCH_FLOATING_TYPES(z.type(), "elu_backward_cpu", ([&] { + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "elu_backward_cpu", ([&] { int64_t count = z.numel(); - auto *_z = z.data(); - auto *_dz = dz.data(); + auto *_z = z.data_ptr(); + auto *_dz = dz.data_ptr(); for (int64_t i = 0; i < count; ++i) { if (_z[i] < 0) { diff --git a/schp/modules/src/inplace_abn_cpu_only.cpp b/schp/modules/src/inplace_abn_cpu_only.cpp index 18f09eb..67a7223 100644 --- a/schp/modules/src/inplace_abn_cpu_only.cpp +++ b/schp/modules/src/inplace_abn_cpu_only.cpp @@ -8,7 +8,7 @@ std::vector mean_var(at::Tensor x) { if (x.is_cuda()) { - if (x.type().scalarType() == at::ScalarType::Half) + if (x.scalar_type() == at::ScalarType::Half) { return mean_var_cuda_h(x); } @@ -46,7 +46,7 @@ at::Tensor forward(at::Tensor x, at::Tensor mean, at::Tensor var, at::Tensor wei { if (x.is_cuda()) { - if (x.type().scalarType() == at::ScalarType::Half) + if (x.scalar_type() == at::ScalarType::Half) { return forward_cuda_h(x, mean, var, weight, bias, affine, eps); } @@ -66,7 +66,7 @@ std::vector edz_eydz(at::Tensor z, at::Tensor dz, at::Tensor weight, { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return edz_eydz_cuda_h(z, dz, weight, bias, affine, eps); } @@ -86,7 +86,7 @@ at::Tensor backward(at::Tensor z, at::Tensor dz, at::Tensor var, at::Tensor weig { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return backward_cuda_h(z, dz, var, weight, bias, edz, eydz, affine, eps); } @@ -110,7 +110,7 @@ void leaky_relu_backward(at::Tensor z, at::Tensor dz, float slope) { if (z.is_cuda()) { - if (z.type().scalarType() == at::ScalarType::Half) + if (z.scalar_type() == at::ScalarType::Half) { return leaky_relu_backward_cuda_h(z, dz, slope); } diff --git a/schp/modules/src/inplace_abn_cuda.cu b/schp/modules/src/inplace_abn_cuda.cu index b157b06..5cf2c6b 100644 --- a/schp/modules/src/inplace_abn_cuda.cu +++ b/schp/modules/src/inplace_abn_cuda.cu @@ -89,11 +89,11 @@ std::vector mean_var_cuda(at::Tensor x) { dim3 blocks(chn); dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); - AT_DISPATCH_FLOATING_TYPES(x.type(), "mean_var_cuda", ([&] { + AT_DISPATCH_FLOATING_TYPES(x.scalar_type(), "mean_var_cuda", ([&] { mean_var_kernel<<>>( - x.data(), - mean.data(), - var.data(), + x.data_ptr(), + mean.data_ptr(), + var.data_ptr(), num, chn, sp); })); @@ -142,13 +142,13 @@ at::Tensor forward_cuda(at::Tensor x, at::Tensor mean, at::Tensor var, at::Tenso dim3 blocks(chn); dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); - AT_DISPATCH_FLOATING_TYPES(x.type(), "forward_cuda", ([&] { + AT_DISPATCH_FLOATING_TYPES(x.scalar_type(), "forward_cuda", ([&] { forward_kernel<<>>( - x.data(), - mean.data(), - var.data(), - weight.data(), - bias.data(), + x.data_ptr(), + mean.data_ptr(), + var.data_ptr(), + weight.data_ptr(), + bias.data_ptr(), affine, eps, num, chn, sp); })); @@ -194,14 +194,14 @@ std::vector edz_eydz_cuda(at::Tensor z, at::Tensor dz, at::Tensor we dim3 blocks(chn); dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); - AT_DISPATCH_FLOATING_TYPES(z.type(), "edz_eydz_cuda", ([&] { + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "edz_eydz_cuda", ([&] { edz_eydz_kernel<<>>( - z.data(), - dz.data(), - weight.data(), - bias.data(), - edz.data(), - eydz.data(), + z.data_ptr(), + dz.data_ptr(), + weight.data_ptr(), + bias.data_ptr(), + edz.data_ptr(), + eydz.data_ptr(), affine, eps, num, chn, sp); })); @@ -256,16 +256,16 @@ at::Tensor backward_cuda(at::Tensor z, at::Tensor dz, at::Tensor var, at::Tensor dim3 blocks(chn); dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); - AT_DISPATCH_FLOATING_TYPES(z.type(), "backward_cuda", ([&] { + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "backward_cuda", ([&] { backward_kernel<<>>( - z.data(), - dz.data(), - var.data(), - weight.data(), - bias.data(), - edz.data(), - eydz.data(), - dx.data(), + z.data_ptr(), + dz.data_ptr(), + var.data_ptr(), + weight.data_ptr(), + bias.data_ptr(), + edz.data_ptr(), + eydz.data_ptr(), + dx.data_ptr(), affine, eps, num, chn, sp); })); @@ -299,8 +299,8 @@ void leaky_relu_backward_cuda(at::Tensor z, at::Tensor dz, float slope) { int64_t count = z.numel(); - AT_DISPATCH_FLOATING_TYPES(z.type(), "leaky_relu_backward_cuda", ([&] { - leaky_relu_backward_impl(z.data(), dz.data(), slope, count); + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "leaky_relu_backward_cuda", ([&] { + leaky_relu_backward_impl(z.data_ptr(), dz.data_ptr(), slope, count); })); } @@ -327,7 +327,7 @@ void elu_backward_cuda(at::Tensor z, at::Tensor dz) { int64_t count = z.numel(); - AT_DISPATCH_FLOATING_TYPES(z.type(), "leaky_relu_backward_cuda", ([&] { - elu_backward_impl(z.data(), dz.data(), count); + AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "elu_backward_cuda", ([&] { + elu_backward_impl(z.data_ptr(), dz.data_ptr(), count); })); } diff --git a/schp/modules/src/inplace_abn_cuda_half.cu b/schp/modules/src/inplace_abn_cuda_half.cu index bb63e73..17988de 100644 --- a/schp/modules/src/inplace_abn_cuda_half.cu +++ b/schp/modules/src/inplace_abn_cuda_half.cu @@ -85,9 +85,9 @@ std::vector mean_var_cuda_h(at::Tensor x) { dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); mean_var_kernel_h<<>>( - reinterpret_cast(x.data()), - mean.data(), - var.data(), + reinterpret_cast(x.data_ptr()), + mean.data_ptr(), + var.data_ptr(), num, chn, sp); return {mean, var}; @@ -136,11 +136,11 @@ at::Tensor forward_cuda_h(at::Tensor x, at::Tensor mean, at::Tensor var, at::Ten dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); forward_kernel_h<<>>( - reinterpret_cast(x.data()), - mean.data(), - var.data(), - weight.data(), - bias.data(), + reinterpret_cast(x.data_ptr()), + mean.data_ptr(), + var.data_ptr(), + weight.data_ptr(), + bias.data_ptr(), affine, eps, num, chn, sp); return x; @@ -181,12 +181,12 @@ std::vector edz_eydz_cuda_h(at::Tensor z, at::Tensor dz, at::Tensor dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); edz_eydz_kernel_h<<>>( - reinterpret_cast(z.data()), - reinterpret_cast(dz.data()), - weight.data(), - bias.data(), - edz.data(), - eydz.data(), + reinterpret_cast(z.data_ptr()), + reinterpret_cast(dz.data_ptr()), + weight.data_ptr(), + bias.data_ptr(), + edz.data_ptr(), + eydz.data_ptr(), affine, eps, num, chn, sp); return {edz, eydz}; @@ -236,14 +236,14 @@ at::Tensor backward_cuda_h(at::Tensor z, at::Tensor dz, at::Tensor var, at::Tens dim3 threads(getNumThreads(sp)); auto stream = at::cuda::getCurrentCUDAStream(); backward_kernel_h<<>>( - reinterpret_cast(z.data()), - reinterpret_cast(dz.data()), - var.data(), - weight.data(), - bias.data(), - edz.data(), - eydz.data(), - reinterpret_cast(dx.data()), + reinterpret_cast(z.data_ptr()), + reinterpret_cast(dz.data_ptr()), + var.data_ptr(), + weight.data_ptr(), + bias.data_ptr(), + edz.data_ptr(), + eydz.data_ptr(), + reinterpret_cast(dx.data_ptr()), affine, eps, num, chn, sp); return dx; @@ -268,8 +268,8 @@ void leaky_relu_backward_cuda_h(at::Tensor z, at::Tensor dz, float slope) { dim3 blocks = (count + threads.x - 1) / threads.x; auto stream = at::cuda::getCurrentCUDAStream(); leaky_relu_backward_impl_h<<>>( - reinterpret_cast(z.data()), - reinterpret_cast(dz.data()), + reinterpret_cast(z.data_ptr()), + reinterpret_cast(dz.data_ptr()), slope, count); } diff --git a/schp/modules/src/utils/checks.h b/schp/modules/src/utils/checks.h index e761a6f..a239730 100644 --- a/schp/modules/src/utils/checks.h +++ b/schp/modules/src/utils/checks.h @@ -7,9 +7,9 @@ #define AT_CHECK AT_ASSERT #endif -#define CHECK_CUDA(x) AT_CHECK((x).type().is_cuda(), #x " must be a CUDA tensor") -#define CHECK_CPU(x) AT_CHECK(!(x).type().is_cuda(), #x " must be a CPU tensor") -#define CHECK_CONTIGUOUS(x) AT_CHECK((x).is_contiguous(), #x " must be contiguous") +#define CHECK_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_CONTIGUOUS(x) TORCH_CHECK((x).is_contiguous(), #x " must be contiguous") #define CHECK_CUDA_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x) #define CHECK_CPU_INPUT(x) CHECK_CPU(x); CHECK_CONTIGUOUS(x) \ No newline at end of file