nodes/cozymantis-human-parser-comfyui-node
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix for human-parser-comfyui-node Torch 2.11 Compatibility

Browse Source 
The `human-parser-comfyui-node` uses the `inplace_abn` library which contains deprecated PyTorch C++ API calls that were removed in PyTorch 2.11.
This commit is contained in:
yungYEEZY
2026-04-13 18:20:46 +03:00
committed by Gabi Dobocan
parent c3123b9616
commit 0ce414f7c9
7 changed files with 76 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files
schp/modules/src/checks.h
+3 -8
View File
@@ -2,14 +2,9 @@
#include <ATen/ATen.h>
// 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)
schp/modules/src/inplace_abn.cpp
+5 -5
View File
@@ -8,7 +8,7 @@ std::vector<at::Tensor> 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<at::Tensor> 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);
}
schp/modules/src/inplace_abn_cpu.cpp
+6 -6
View File
@@ -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<scalar_t>();
auto *_dz = dz.data<scalar_t>();
auto *_z = z.data_ptr<scalar_t>();
auto *_dz = dz.data_ptr<scalar_t>();
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<scalar_t>();
auto *_dz = dz.data<scalar_t>();
auto *_z = z.data_ptr<scalar_t>();
auto *_dz = dz.data_ptr<scalar_t>();
for (int64_t i = 0; i < count; ++i) {
if (_z[i] < 0) {
schp/modules/src/inplace_abn_cpu_only.cpp
+5 -5
View File
@@ -8,7 +8,7 @@ std::vector<at::Tensor> 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<at::Tensor> 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);
}
schp/modules/src/inplace_abn_cuda.cu
+30 -30
View File
@@ -89,11 +89,11 @@ std::vector<at::Tensor> 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<scalar_t><<<blocks, threads, 0, stream>>>(
x.data<scalar_t>(),
mean.data<scalar_t>(),
var.data<scalar_t>(),
x.data_ptr<scalar_t>(),
mean.data_ptr<scalar_t>(),
var.data_ptr<scalar_t>(),
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<scalar_t><<<blocks, threads, 0, stream>>>(
x.data<scalar_t>(),
mean.data<scalar_t>(),
var.data<scalar_t>(),
weight.data<scalar_t>(),
bias.data<scalar_t>(),
x.data_ptr<scalar_t>(),
mean.data_ptr<scalar_t>(),
var.data_ptr<scalar_t>(),
weight.data_ptr<scalar_t>(),
bias.data_ptr<scalar_t>(),
affine, eps, num, chn, sp);
}));
@@ -194,14 +194,14 @@ std::vector<at::Tensor> 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<scalar_t><<<blocks, threads, 0, stream>>>(
z.data<scalar_t>(),
dz.data<scalar_t>(),
weight.data<scalar_t>(),
bias.data<scalar_t>(),
edz.data<scalar_t>(),
eydz.data<scalar_t>(),
z.data_ptr<scalar_t>(),
dz.data_ptr<scalar_t>(),
weight.data_ptr<scalar_t>(),
bias.data_ptr<scalar_t>(),
edz.data_ptr<scalar_t>(),
eydz.data_ptr<scalar_t>(),
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<scalar_t><<<blocks, threads, 0, stream>>>(
z.data<scalar_t>(),
dz.data<scalar_t>(),
var.data<scalar_t>(),
weight.data<scalar_t>(),
bias.data<scalar_t>(),
edz.data<scalar_t>(),
eydz.data<scalar_t>(),
dx.data<scalar_t>(),
z.data_ptr<scalar_t>(),
dz.data_ptr<scalar_t>(),
var.data_ptr<scalar_t>(),
weight.data_ptr<scalar_t>(),
bias.data_ptr<scalar_t>(),
edz.data_ptr<scalar_t>(),
eydz.data_ptr<scalar_t>(),
dx.data_ptr<scalar_t>(),
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<scalar_t>(z.data<scalar_t>(), dz.data<scalar_t>(), slope, count);
AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "leaky_relu_backward_cuda", ([&] {
leaky_relu_backward_impl<scalar_t>(z.data_ptr<scalar_t>(), dz.data_ptr<scalar_t>(), 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<scalar_t>(z.data<scalar_t>(), dz.data<scalar_t>(), count);
AT_DISPATCH_FLOATING_TYPES(z.scalar_type(), "elu_backward_cuda", ([&] {
elu_backward_impl<scalar_t>(z.data_ptr<scalar_t>(), dz.data_ptr<scalar_t>(), count);
}));
}
schp/modules/src/inplace_abn_cuda_half.cu
+24 -24
View File
@@ -85,9 +85,9 @@ std::vector<at::Tensor> mean_var_cuda_h(at::Tensor x) {
dim3 threads(getNumThreads(sp));
auto stream = at::cuda::getCurrentCUDAStream();
mean_var_kernel_h<<<blocks, threads, 0, stream>>>(
reinterpret_cast<half*>(x.data<at::Half>()),
mean.data<float>(),
var.data<float>(),
reinterpret_cast<half*>(x.data_ptr<at::Half>()),
mean.data_ptr<float>(),
var.data_ptr<float>(),
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<<<blocks, threads, 0, stream>>>(
reinterpret_cast<half*>(x.data<at::Half>()),
mean.data<float>(),
var.data<float>(),
weight.data<float>(),
bias.data<float>(),
reinterpret_cast<half*>(x.data_ptr<at::Half>()),
mean.data_ptr<float>(),
var.data_ptr<float>(),
weight.data_ptr<float>(),
bias.data_ptr<float>(),
affine, eps, num, chn, sp);
return x;
@@ -181,12 +181,12 @@ std::vector<at::Tensor> 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<<<blocks, threads, 0, stream>>>(
reinterpret_cast<half*>(z.data<at::Half>()),
reinterpret_cast<half*>(dz.data<at::Half>()),
weight.data<float>(),
bias.data<float>(),
edz.data<float>(),
eydz.data<float>(),
reinterpret_cast<half*>(z.data_ptr<at::Half>()),
reinterpret_cast<half*>(dz.data_ptr<at::Half>()),
weight.data_ptr<float>(),
bias.data_ptr<float>(),
edz.data_ptr<float>(),
eydz.data_ptr<float>(),
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<<<blocks, threads, 0, stream>>>(
reinterpret_cast<half*>(z.data<at::Half>()),
reinterpret_cast<half*>(dz.data<at::Half>()),
var.data<float>(),
weight.data<float>(),
bias.data<float>(),
edz.data<float>(),
eydz.data<float>(),
reinterpret_cast<half*>(dx.data<at::Half>()),
reinterpret_cast<half*>(z.data_ptr<at::Half>()),
reinterpret_cast<half*>(dz.data_ptr<at::Half>()),
var.data_ptr<float>(),
weight.data_ptr<float>(),
bias.data_ptr<float>(),
edz.data_ptr<float>(),
eydz.data_ptr<float>(),
reinterpret_cast<half*>(dx.data_ptr<at::Half>()),
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<<<blocks, threads, 0, stream>>>(
reinterpret_cast<half*>(z.data<at::Half>()),
reinterpret_cast<half*>(dz.data<at::Half>()),
reinterpret_cast<half*>(z.data_ptr<at::Half>()),
reinterpret_cast<half*>(dz.data_ptr<at::Half>()),
slope, count);
}
schp/modules/src/utils/checks.h
+3 -3
View File
@@ -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)