"Operating System :: OS Independent",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
license="Apache License 2.0",
setup_requires=["pytest-runner", "cython", "numpy"],
tests_require=["pytest"],
install_requires=get_requirements(),
ext_modules=[
CUDAExtension(
name="det3d.ops.pointnet2.PN2",
sources=glob.glob("det3d/ops/pointnet2/src/*.cpp")
+ glob.glob("det3d/ops/pointnet2/src/*.cu"),
extra_compile_args={"cxx": ["-g",], "nvcc": ["-g",],},
),
CUDAExtension(
name="det3d.ops.rroi_align.RotateRoIAlign",
sources=[
"det3d/ops/rroi_align/ROIAlign_cuda.cpp",
"det3d/ops/rroi_align/ROIAlign_cuda_kernel.cu",
],
),
CUDAExtension(
name="det3d.ops.roipool3d.RoIPool3D",
sources=[
"det3d/ops/roipool3d/src/roipool3d.cpp",
"det3d/ops/roipool3d/src/roipool3d_kernel.cu",
],
# extra_compile_args['nvcc'] += ['--compiler-bindir', '/sw/arcts/centos7/gcc/8.2.0/bin/g++']
# # extra_compile_args = dict()
# os.environ["CC"] = "/sw/arcts/centos7/gcc/8.2.0/bin/gcc"
# os.environ["CXX"] = "/sw/arcts/centos7/gcc/8.2.0/bin/g++"
setup(
name='c3d',
description='Package for Continuous 3D Loss',
author='Minghan Zhu',
author_email='*****@*****.**',
url='https://github.com/minghanz/c3d',
ext_modules=[
CUDAExtension('c3d.cvo_ops.sub_cuda', [
'c3d/cvo_ops/custom_ori/sub_cuda.cpp',
'c3d/cvo_ops/custom_ori/sub_cuda_kernel.cu',
],
extra_compile_args=extra_compile_args),
CUDAExtension('c3d.cvo_ops.sub_norm_cuda_half_paral', [
'c3d/cvo_ops/custom_norm/sub_norm_cuda.cpp',
'c3d/cvo_ops/custom_norm/sub_norm_cuda_kernel.cu',
],
extra_compile_args=extra_compile_args),
CUDAExtension('c3d.cvo_ops.cvo_dense_with_normal_output', [
'c3d/cvo_ops/custom_dense_with_normal/cvo_dense_with_normal_cuda.cpp',
'c3d/cvo_ops/custom_dense_with_normal/cvo_dense_with_normal_cuda_kernel.cu',
],
extra_compile_args=extra_compile_args),
CUDAExtension('c3d.cvo_ops.cvo_dense_normal', [
'c3d/cvo_ops/custom_dense_normal/cvo_dense_normal_cuda.cpp',
'c3d/cvo_ops/custom_dense_normal/cvo_dense_normal_cuda_kernel.cu',
install_requires = ['scipy']
setup_requires = ['pytest-runner']
tests_require = ['pytest', 'pytest-cov']
ext_modules = []
cmdclass = {}
if CUDA_HOME is not None:
if platform.system() == 'Windows':
extra_link_args = 'cusparse.lib'
else:
extra_link_args = ['-lcusparse', '-l', 'cusparse'],
ext_modules += [
CUDAExtension(
'spspmm_cuda', ['cuda/spspmm.cpp', 'cuda/spspmm_kernel.cu'],
extra_link_args=extra_link_args),
CUDAExtension('unique_cuda',
['cuda/unique.cpp', 'cuda/unique_kernel.cu']),
]
cmdclass['build_ext'] = BuildExtension
setup(
name='torch_sparse',
version=__version__,
description='PyTorch Extension Library of Optimized Autograd Sparse '
'Matrix Operations',
author='Matthias Fey',
author_email='*****@*****.**',
url=url,
download_url='{}/archive/{}.tar.gz'.format(url, __version__),
GPU = True
for arg in argv:
if arg == '--cpu':
GPU = False
argv.remove(arg)
if CUDA_HOME is not None and GPU:
if platform.system() == 'Windows':
extra_link_args = ['cusparse.lib']
else:
extra_link_args = ['-lcusparse', '-l', 'cusparse']
ext_modules += [
CUDAExtension('torch_sparse.spspmm_cuda',
['cuda/spspmm.cpp', 'cuda/spspmm_kernel.cu'],
extra_link_args=extra_link_args,
extra_compile_args=extra_compile_args),
CUDAExtension('torch_sparse.unique_cuda',
['cuda/unique.cpp', 'cuda/unique_kernel.cu'],
extra_compile_args=extra_compile_args),
]
__version__ = '0.4.3'
url = 'https://github.com/rusty1s/pytorch_sparse'
install_requires = ['scipy']
setup_requires = ['pytest-runner']
tests_require = ['pytest', 'pytest-cov']
setup(
name='torch_sparse',
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
setup(name='fps_cuda',
ext_modules=[
CUDAExtension('fps_cuda', [
'fps_cuda.cpp',
'fps_cuda_kernel.cu',
]),
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup, Extension
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
setup(name='int_im2col',
ext_modules=[
CUDAExtension('int_im2col_cuda',
['int_im2col.cpp', 'int_im2col_kernel.cu'],
include_dirs=['/niti/pytorch/int8im2col-extension'])
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
setup(name='lltm_cuda',
ext_modules=[
CUDAExtension('lltm_cuda', [
'lltm_cuda.cpp',
'lltm_cuda_kernel.cu',
]),
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup
from torch.utils.cpp_extension import CUDAExtension, BuildExtension
setup(name='dynamicconv_layer',
ext_modules=[
CUDAExtension(
name='dynamicconv_cuda',
sources=[
'dynamicconv_cuda.cpp',
'dynamicconv_cuda_kernel.cu',
],
),
],
cmdclass={'build_ext': BuildExtension})
#!/usr/bin/env python
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
setup(name='deform_conv',
ext_modules=[
CUDAExtension('deform_conv_cuda', [
'src/deform_conv_cuda.cpp',
'src/deform_conv_cuda_kernel.cu',
]),
CUDAExtension(
'deform_pool_cuda',
['src/deform_pool_cuda.cpp', 'src/deform_pool_cuda_kernel.cu']),
],
cmdclass={'build_ext': BuildExtension})
with open("README.md", "r") as fh:
long_description = fh.read()
'''
nvcc_args = [
'-gencode', 'arch=compute_61,code=sm_61',
'-gencode', 'arch=compute_70,code=sm_70',
'-gencode', 'arch=compute_70,code=compute_70'
]
cxx_args = ['-std=c++11']
setup(
name='self_cuda',
#version="0.1.0",
#author="Clément Pinard",
#author_email="*****@*****.**",
#description="Correlation module for pytorch",
#long_description=long_description,
#long_description_content_type="text/markdown",
#url="https://github.com/ClementPinard/Pytorch-Correlation-extension",
#install_requires=['torch>=1.0.1','numpy'],
ext_modules=[
CUDAExtension('self_cuda_backend',
sources, extra_compile_args={'cxx': cxx_args,'nvcc': nvcc_args})
],
#package_dir={'': project_root},
#packages=['spatial_correlation_sampler'],
cmdclass={
'build_ext': BuildExtension
})
from setuptools import setup
from torch.utils.cpp_extension import CUDAExtension, BuildExtension
# Python interface
setup(
name='PyTorchStructuralLosses',
version='0.1.0',
install_requires=['torch'],
packages=['StructuralLosses'],
package_dir={'StructuralLosses': './'},
ext_modules=[
CUDAExtension(
name='StructuralLossesBackend',
include_dirs=['./'],
sources=[
'pybind/bind.cpp',
],
libraries=['make_pytorch'],
library_dirs=['objs'],
# extra_compile_args=['-g']
)
],
cmdclass={'build_ext': BuildExtension},
author='Christopher B. Choy',
author_email='*****@*****.**',
description='Tutorial for Pytorch C++ Extension with a Makefile',
keywords='Pytorch C++ Extension',
url='https://github.com/chrischoy/MakePytorchPlusPlus',
zip_safe=False,
)
#!/usr/bin/env python3
import os
import torch
from setuptools import setup, find_packages
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
cxx_args = ['-std=c++11']
nvcc_args = [
'-gencode', 'arch=compute_50,code=sm_50', '-gencode',
'arch=compute_52,code=sm_52', '-gencode', 'arch=compute_60,code=sm_60',
'-gencode', 'arch=compute_75,code=sm_75'
# '-gencode', 'arch=compute_70,code=sm_70',
# '-gencode', 'arch=compute_70,code=compute_70'
]
setup(name='separableconv_cuda',
ext_modules=[
CUDAExtension(
'separableconv_cuda',
['separableconv_cuda.cc', 'separableconv_cuda_kernel.cu'],
extra_compile_args={
'cxx': cxx_args,
'nvcc': nvcc_args
})
],
cmdclass={'build_ext': BuildExtension})
name='odtk',
version='0.2.4',
description='Fast and accurate single shot object detector',
author='NVIDIA Corporation',
packages=['retinanet', 'retinanet.backbones'],
ext_modules=[
CUDAExtension('retinanet._C', [
'csrc/extensions.cpp', 'csrc/engine.cpp', 'csrc/cuda/decode.cu',
'csrc/cuda/decode_rotate.cu', 'csrc/cuda/nms.cu',
'csrc/cuda/nms_iou.cu'
],
extra_compile_args={
'cxx': ['-std=c++14', '-O2', '-Wall'],
'nvcc': [
'-std=c++14', '--expt-extended-lambda',
'--use_fast_math', '-Xcompiler', '-Wall',
'-gencode=arch=compute_60,code=sm_60',
'-gencode=arch=compute_61,code=sm_61',
'-gencode=arch=compute_70,code=sm_70',
'-gencode=arch=compute_72,code=sm_72',
'-gencode=arch=compute_75,code=sm_75',
'-gencode=arch=compute_75,code=compute_75'
],
},
libraries=['nvinfer', 'nvinfer_plugin', 'nvonnxparser'])
],
cmdclass={
'build_ext': BuildExtension.with_options(no_python_abi_suffix=True)
},
install_requires=[
'torch>=1.0.0a0',
#!/usr/bin/env python3
import os
import torch
from setuptools import setup, find_packages
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
from compiler_args import nvcc_args, cxx_args
setup(name='mindepthflowprojection_cuda',
ext_modules=[
CUDAExtension('mindepthflowprojection_cuda', [
'mindepthflowprojection_cuda.cc',
'mindepthflowprojection_cuda_kernel.cu'
],
extra_compile_args={
'cxx': cxx_args,
'nvcc': nvcc_args
})
],
cmdclass={'build_ext': BuildExtension})
CUDAExtension(
name="fbgemm_gpu_py",
sources=[
os.path.join(cur_dir, build_codegen_path, "{}".format(f))
for f in cpp_cuda_output_files + cpp_cpu_output_files
] + cpp_asmjit_files + cpp_fbgemm_files + [
os.path.join(cur_dir,
"codegen/embedding_forward_split_cpu.cpp"),
os.path.join(cur_dir,
"codegen/embedding_backward_dense_host_cpu.cpp"),
os.path.join(cur_dir,
"codegen/embedding_backward_dense_host.cpp"),
os.path.join(cur_dir, "src/split_embeddings_cache_cuda.cu"),
os.path.join(cur_dir,
"src/split_table_batched_embeddings.cpp"),
os.path.join(cur_dir, "src/cumem_utils.cu"),
os.path.join(cur_dir, "src/cumem_utils_host.cpp"),
os.path.join(cur_dir, "src/quantize_wrappers.cu"),
os.path.join(cur_dir, "src/quantize_ops_host.cpp"),
os.path.join(cur_dir, "src/quantize_ops.cpp"),
],
include_dirs=[
cur_dir,
os.path.join(cur_dir, "include"),
os.path.join(cur_dir, "../include"),
os.path.join(cur_dir, "../src"),
os.path.join(cur_dir, "../third_party/asmjit/src"),
os.path.join(cur_dir, "../third_party/asmjit/src/core"),
os.path.join(cur_dir, "../third_party/asmjit/src/x86"),
os.path.join(cur_dir, "../third_party/cpuinfo/include"),
cub_include_path,
],
)
from setuptools import setup, Extension
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
v4r_path = "/home/bps/rl/v4r"
include_dir = v4r_path + "/include"
lib_dir = v4r_path + "/build/src"
setup(name='v4r_example',
ext_modules=[
CUDAExtension(name='v4r_example',
sources=['v4r_example.cpp'],
extra_compile_args=[f"-I{include_dir}"],
extra_link_args=[
f"-L{lib_dir}", "-lv4r", "-Wl,--no-as-needed",
"-lv4r_headless_hacks", f"-Wl,-rpath={lib_dir}"
])
],
cmdclass={'build_ext': BuildExtension})
import os
import torch
from setuptools import setup, find_packages
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
cxx_args = ['-std=c++11']
nvcc_args = [
'-gencode', 'arch=compute_75,code=sm_75'
#'-gencode', 'arch=compute_50,code=sm_50',
#'-gencode', 'arch=compute_52,code=sm_52',
#'-gencode', 'arch=compute_60,code=sm_60',
#'-gencode', 'arch=compute_61,code=sm_61'
# '-gencode', 'arch=compute_70,code=sm_70',
# '-gencode', 'arch=compute_70,code=compute_70'
]
setup(
name='filterinterpolation_cuda',
ext_modules=[
CUDAExtension('filterinterpolation_cuda', [
'filterinterpolation_cuda.cc', 'filterinterpolation_cuda_kernel.cu'
],
extra_compile_args={
'cxx': cxx_args,
'nvcc': nvcc_args
})
],
cmdclass={'build_ext': BuildExtension})
#import setuptools
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
import os
#torch.utils.cpp_extension.include_paths(),
######################################################################
############## compile with python setup.py install ##############
######################################################################
# note that python MUST use gcc vf version >4.8 ! else this will segfault
# this indeed uses the respective version to compile ! so could manually set here if wanted..
#os.environ["CC"] = "g++-4.9"
#os.environ["CXX"] = "g++-4.9"
setup(name='QuadFit_cuda',
include_dirs=[
os.path.join(os.environ['IMAGEUTILITIES_ROOT'], 'include'),
'/home/vogechri/.local/include/'
],
ext_modules=[
CUDAExtension('QuadFit_cuda_ext', [
'QuadFit_cuda.cpp',
'cudaCode/quadFit.cu',
]),
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
setup(
name='emd',
ext_modules=[
CUDAExtension('emd', [
'emd_cuda.cpp',
'emd.cu',
]),
],
cmdclass={
'build_ext': BuildExtension
})
##
# @file setup.py
# @author Yibo Lin
# @date Jun 2018
#
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDAExtension
setup(name='dct',
ext_modules=[
CppExtension('dct_cpp',
['dct.cpp', 'dst.cpp', 'dxt.cpp', 'dct_2N.cpp']),
CUDAExtension('dct_cuda', [
'dct_cuda.cpp', 'dct_cuda_kernel.cu', 'dst_cuda.cpp',
'dst_cuda_kernel.cu', 'dxt_cuda.cpp', 'dct_2N_cuda.cpp'
]),
CppExtension('dct_lee_cpp', ['dct_lee.cpp']),
CUDAExtension('dct_lee_cuda', [
'dct_lee_cuda.cpp', 'dct_lee_cuda_kernel.cu',
'dct_cuda_kernel.cu', 'dst_cuda_kernel.cu'
]),
],
cmdclass={'build_ext': BuildExtension})
]
if CUDA_MAJOR > 8:
gencodes += [
'-gencode',
'arch=compute_70,code=sm_70',
'-gencode',
'arch=compute_70,code=compute_70',
]
ext_modules = []
extension = CUDAExtension('apex_C', [
'csrc/interface.cpp',
'csrc/weight_norm_fwd_cuda.cu',
'csrc/weight_norm_bwd_cuda.cu',
'csrc/scale_cuda.cu',
],
extra_compile_args={
'cxx': ['-g'] + version_le_04,
'nvcc': ['-O3'] + version_le_04 + gencodes
})
ext_modules.append(extension)
else:
raise RuntimeError("Could not find Cuda install directory")
setup(
name='apex',
version='0.1',
packages=find_packages(exclude=(
'build',
'csrc',
'include',
#!/usr/bin/env python3
import os
import torch
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
cxx_args = ['-std=c++11']
nvcc_args = [
'-gencode', 'arch=compute_37,code=sm_37',
'-gencode', 'arch=compute_52,code=sm_52',
'-gencode', 'arch=compute_60,code=sm_60',
'-gencode', 'arch=compute_61,code=sm_61',
'-gencode', 'arch=compute_70,code=sm_70',
'-gencode', 'arch=compute_70,code=compute_70'
]
setup(
name='channelnorm_cuda',
ext_modules=[
CUDAExtension('channelnorm_cuda', [
'channelnorm_cuda.cc',
'channelnorm_kernel.cu'
], extra_compile_args={'cxx': cxx_args, 'nvcc': nvcc_args})
],
cmdclass={
'build_ext': BuildExtension
})
# pylint: disable=not-callable, no-member, invalid-name, line-too-long, wildcard-import, unused-wildcard-import, missing-docstring, bare-except
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
from pack import KWARGS
ext_modules = [
CUDAExtension(
'e3nn.cuda_rsh',
sources=['src/cuda_rsh/rsh_bind.cpp', 'src/cuda_rsh/rsh_cuda.cu'],
extra_compile_args={
'cxx': ['-std=c++14'],
'nvcc': ['-std=c++14']
})
]
setup(ext_modules=ext_modules,
cmdclass={'build_ext': BuildExtension},
**KWARGS)
from setuptools import setup
import torch
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
PACKAGE_NAME = 'mesh2sdf'
VERSION = '0.1.0'
DESCRIPTION = 'Fast CUDA kernel for computing SDF of triangle mesh'
AUTHOR = 'Zekun Hao et al.'
URL = 'https://github.com/zekunhao1995/DualSDF'
LICENSE = 'MIT'
# Standalone package (old way)
setup(name=PACKAGE_NAME,
version=VERSION,
description=DESCRIPTION,
author=AUTHOR,
url=URL,
license=LICENSE,
ext_modules=[
CUDAExtension(name='mesh2sdf',
sources=['mesh2sdf_kernel.cu'],
extra_compile_args={
'cxx': ['-std=c++14', '-ffast-math'],
'nvcc': ['-std=c++14']
})
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup, find_packages
from torch.utils.cpp_extension import CUDAExtension, BuildExtension
import os
from pathlib import Path
LIB_NAME = "torch_batch_svd"
MAJOR = 1
MINOR = 0
PATCH = 0
root_dir = Path(LIB_NAME)
include_dir = root_dir / 'include'
ext_src = [str(x.absolute()) for x in root_dir.glob('csrc/*.cpp')]
print(ext_src)
cuda_extension = CUDAExtension(LIB_NAME + '._c',
sources=ext_src,
libraries=["cusolver", "cublas"],
extra_compile_args={
'cxx':
['-O2', '-I{}'.format(str(include_dir))],
'nvcc': ['-O2']
})
setup(name=LIB_NAME,
version='{}.{}.{}'.format(MAJOR, MINOR, PATCH),
packages=find_packages(exclude=('tests', 'build', 'csrc', 'include',
'torch_batch_svd.egg-info')),
ext_modules=[cuda_extension],
cmdclass={'build_ext': BuildExtension.with_options(use_ninja=False)})
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
import glob
_ext_src_root = "_ext_src"
_ext_sources = glob.glob("{}/src/*.cpp".format(_ext_src_root)) + glob.glob(
"{}/src/*.cu".format(_ext_src_root))
_ext_headers = glob.glob("{}/include/*".format(_ext_src_root))
setup(name='weighted_FPS',
ext_modules=[
CUDAExtension(
name='weighted_FPS._ext',
sources=_ext_sources,
extra_compile_args={
"cxx":
["-O2", "-I{}".format("{}/include".format(_ext_src_root))],
"nvcc":
["-O2", "-I{}".format("{}/include".format(_ext_src_root))],
},
)
],
cmdclass={'build_ext': BuildExtension.with_options(use_ninja=False)})
import os
import os.path as osp
from setuptools import find_packages, setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
this_dir = osp.dirname(osp.abspath(__file__))
_ext_src_root = osp.join("_ext-src")
_ext_sources = glob.glob("{}/src/*.cpp".format(_ext_src_root)) + glob.glob(
"{}/src/*.cu".format(_ext_src_root)
)
_ext_headers = glob.glob("{}/include/*".format(_ext_src_root))
os.environ["TORCH_CUDA_ARCH_LIST"] = "3.7+PTX;5.0;6.0;6.1;6.2;7.0;7.5"
setup(
name='pointnet2',
ext_modules=[
CUDAExtension(
name='pointnet2._ext',
sources=_ext_sources,
extra_compile_args={
"cxx": ["-O3"],
"nvcc": ["-O3", "-Xfatbin", "-compress-all"],
},
include_dirs=[osp.join(this_dir, _ext_src_root, "include")],
)
],
cmdclass={"build_ext": BuildExtension},
include_package_data=True,
)
# as the library name
names = extension.name.split('.')
name = names[-1]
define = '-DTORCH_EXTENSION_NAME={}'.format(name)
self._add_compile_flag(extension, define)
def _add_gnu_cpp_abi_flag(self, extension):
# use the same CXX ABI as what PyTorch was compiled with
self._add_compile_flag(
extension, '-D_GLIBCXX_USE_CXX11_ABI=' +
str(int(torch._C._GLIBCXX_USE_CXX11_ABI)))
setup(name='nv_wavenet_ext',
ext_modules=[
CUDAExtension('nv_wavenet_ext', [
"wavenet_infer.cu",
"wavenet_infer_wrapper.cpp",
"matrix.cpp",
],
extra_compile_args={
"cxx": ["-std=c++11"],
"nvcc": [
"-arch=sm_60", "-std=c++14", "--use_fast_math",
"-maxrregcount", "128", "--ptxas-options=-v",
"--expt-relaxed-constexpr", "-D__GNUC__=6"
]
}),
],
cmdclass={'build_ext': BuildExtensionWithHalf})
#!/usr/bin/env python3
import os
import torch
from setuptools import setup, find_packages
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
cxx_args = ['-std=c++11']
nvcc_args = [
'-gencode', 'arch=compute_30,code=sm_30', '-gencode',
'arch=compute_35,code=sm_35', '-gencode', 'arch=compute_37,code=sm_37',
'-gencode', 'arch=compute_50,code=sm_50', '-gencode',
'arch=compute_52,code=sm_52', '-gencode', 'arch=compute_60,code=sm_60',
'-gencode', 'arch=compute_61,code=sm_61', '-gencode',
'arch=compute_70,code=sm_70', '-gencode', 'arch=compute_70,code=compute_70'
]
setup(name='correlation_cuda',
ext_modules=[
CUDAExtension('correlation_cuda',
['correlation_cuda.cc', 'correlation_cuda_kernel.cu'],
extra_compile_args={
'cxx': cxx_args,
'nvcc': nvcc_args
})
],
cmdclass={'build_ext': BuildExtension})
from setuptools import setup, find_packages
import torch
from torch.utils.cpp_extension import CppExtension, CUDAExtension, CUDA_HOME
ext_modules = [
CppExtension('torch_cluster.graclus_cpu', ['cpu/graclus.cpp']),
CppExtension('torch_cluster.grid_cpu', ['cpu/grid.cpp']),
CppExtension('torch_cluster.fps_cpu', ['cpu/fps.cpp']),
]
cmdclass = {'build_ext': torch.utils.cpp_extension.BuildExtension}
if CUDA_HOME is not None:
ext_modules += [
CUDAExtension('torch_cluster.graclus_cuda',
['cuda/graclus.cpp', 'cuda/graclus_kernel.cu']),
CUDAExtension('torch_cluster.grid_cuda',
['cuda/grid.cpp', 'cuda/grid_kernel.cu']),
CUDAExtension('torch_cluster.fps_cuda',
['cuda/fps.cpp', 'cuda/fps_kernel.cu']),
CUDAExtension('torch_cluster.nearest_cuda',
['cuda/nearest.cpp', 'cuda/nearest_kernel.cu']),
CUDAExtension('torch_cluster.knn_cuda',
['cuda/knn.cpp', 'cuda/knn_kernel.cu']),
CUDAExtension('torch_cluster.radius_cuda',
['cuda/radius.cpp', 'cuda/radius_kernel.cu']),
CUDAExtension('torch_cluster.rw_cuda',
['cuda/rw.cpp', 'cuda/rw_kernel.cu']),
]
__version__ = '1.2.4'
url = 'https://github.com/rusty1s/pytorch_cluster'
