def run(count_path, out_path, smooth=0, cds=True, normalize=False, neg=1):
counts = create_representation("Explicit", count_path, normalize=False)
old_mat = counts.m
index = counts.wi
smooth = old_mat.sum() * smooth
# getting marginal probs
row_probs = old_mat.sum(1) + smooth
col_probs = old_mat.sum(0) + smooth
if cds:
col_probs = np.power(col_probs, 0.75)
row_probs = row_probs / row_probs.sum()
col_probs = col_probs / col_probs.sum()
# building PPMI matrix
ppmi_mat = make_ppmi_mat(old_mat, row_probs, col_probs, smooth, neg=neg, normalize=normalize)
import pyximport
pyximport.install(setup_args={"include_dirs": np.get_include()})
from representations import sparse_io
sparse_io.export_mat_eff(ppmi_mat.row, ppmi_mat.col, ppmi_mat.data, out_path + ".bin")
util.write_pickle(index, out_path + "-index.pkl")
python类get_include()的实例源码
def configuration(parent_package="", top_path=None):
config = Configuration("metrics", parent_package, top_path)
cblas_libs, blas_info = get_blas_info()
if os.name == 'posix':
cblas_libs.append('m')
config.add_extension("_kernel_fast",
sources=["_kernel_fast.c"],
include_dirs=[os.path.join('..', 'src', 'cblas'),
numpy.get_include(),
blas_info.pop('include_dirs', [])],
libraries=cblas_libs,
extra_compile_args=blas_info.pop('extra_compile_args',
[]),
**blas_info)
config.add_subpackage('tests')
return config
def configuration(parent_package="", top_path=None):
import os
from numpy.distutils.misc_util import Configuration
import numpy
libraries = []
if os.name == 'posix':
libraries.append('m')
config = Configuration("utils", parent_package, top_path)
config.add_extension("_ranking_svm",
sources=["_ranking_svm.c"],
include_dirs=[numpy.get_include()],
libraries=libraries,
extra_compile_args=["-O3"])
config.set_options(ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True)
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('decomposition', parent_package, top_path)
extensions = [
Extension('modl.decomposition.dict_fact_fast',
sources=['modl/decomposition/dict_fact_fast.pyx'],
include_dirs=[numpy.get_include()],
),
Extension('modl.decomposition.recsys_fast',
sources=['modl/decomposition/recsys_fast.pyx'],
include_dirs=[numpy.get_include()],
),
]
config.ext_modules += extensions
config.add_subpackage('tests')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('input_data', parent_package, top_path)
extensions = [
Extension('modl.input_data.image_fast',
sources=['modl/input_data/image_fast.pyx'],
include_dirs=[numpy.get_include()]
),
]
config.add_subpackage('tests')
config.add_subpackage('fmri')
config.ext_modules += extensions
return config
def include_dirs_hook():
if sys.version_info[0] >= 3:
import builtins
if hasattr(builtins, '__NUMPY_SETUP__'):
del builtins.__NUMPY_SETUP__
import imp
import numpy
imp.reload(numpy)
else:
import __builtin__
if hasattr(__builtin__, '__NUMPY_SETUP__'):
del __builtin__.__NUMPY_SETUP__
import numpy
reload(numpy)
ext = Extension('test', [])
ext.include_dirs.append(numpy.get_include())
if not has_include_file(
ext.include_dirs, os.path.join("numpy", "arrayobject.h")):
warnings.warn(
"The C headers for numpy could not be found. "
"You may need to install the development package")
return [numpy.get_include()]
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('polylearn', parent_package, top_path)
config.add_extension('loss_fast', sources=['loss_fast.cpp'],
include_dirs=[numpy.get_include()])
config.add_extension('cd_direct_fast', sources=['cd_direct_fast.cpp'],
include_dirs=[numpy.get_include()])
config.add_extension('cd_linear_fast', sources=['cd_linear_fast.cpp'],
include_dirs=[numpy.get_include()])
config.add_extension('cd_lifted_fast', sources=['cd_lifted_fast.cpp'],
include_dirs=[numpy.get_include()])
config.add_subpackage('tests')
return config
def __init__(self, mjpro_path):
self.mjpro_path = mjpro_path
self.extension = Extension(
'mujoco_py.cymj',
sources=[join(self.CYMJ_DIR_PATH, "cymj.pyx")],
include_dirs=[
self.CYMJ_DIR_PATH,
join(mjpro_path, 'include'),
np.get_include(),
],
libraries=['mujoco150'],
library_dirs=[join(mjpro_path, 'bin')],
extra_compile_args=[
'-fopenmp', # needed for OpenMP
'-w', # suppress numpy compilation warnings
],
extra_link_args=['-fopenmp'],
language='c')
def get_include():
"""
Return the directory that contains the NumPy \\*.h header files.
Extension modules that need to compile against NumPy should use this
function to locate the appropriate include directory.
Notes
-----
When using ``distutils``, for example in ``setup.py``.
::
import numpy as np
...
Extension('extension_name', ...
include_dirs=[np.get_include()])
...
"""
import cykdtree
return os.path.dirname(cykdtree.__file__)
def setup_package():
metadata = dict(name=spfeas_name,
maintainer=maintainer,
maintainer_email=maintainer_email,
description=description,
license=license_file,
version=__version__,
long_description=long_description,
author=author_file,
packages=get_packages(),
package_data=get_package_data(),
ext_modules=cythonize(get_pyx_list()),
include_dirs=[np.get_include()],
cmdclass=dict(build_ext=build_ext),
zip_safe=False,
download_url=git_url,
install_requires=required_packages,
entry_points=get_console_dict())
setup(**metadata)
def configuration(parent_package="", top_path=None):
cblas_libs, blas_info = get_blas_info()
libraries = []
if os.name == 'posix':
cblas_libs.append('m')
libraries.append('m')
config = Configuration("arima", parent_package, top_path)
config.add_extension("_arima",
sources=["_arima.pyx"],
include_dirs=[numpy.get_include(),
blas_info.pop('include_dirs', [])],
libraries=libraries,
extra_compile_args=blas_info.pop(
'extra_compile_args', []),
**blas_info)
config.add_subpackage('tests')
return config
def run(self):
# Check numpy is installed before trying to find the location
# of numpy headers
try:
import numpy
except ImportError:
raise ImportError('numpy need to be installed before GAMtools can be '
'compiled. Try installing with "pip install numpy" '
'before installing GAMtools.')
self.include_dirs.append(numpy.get_include())
build_ext.run(self)
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def configuration(parent_package="", top_path=None):
config = Configuration("decomposition", parent_package, top_path)
libraries = []
if os.name == 'posix':
libraries.append('m')
config.add_extension("_online_lda",
sources=["_online_lda.c"],
include_dirs=[numpy.get_include()],
libraries=libraries)
config.add_extension('cdnmf_fast',
sources=['cdnmf_fast.c'],
include_dirs=[numpy.get_include()],
libraries=libraries)
config.add_subpackage("tests")
return config
def configuration(parent_package="", top_path=None):
config = Configuration("manifold", parent_package, top_path)
libraries = []
if os.name == 'posix':
libraries.append('m')
config.add_extension("_utils",
sources=["_utils.c"],
include_dirs=[numpy.get_include()],
libraries=libraries,
extra_compile_args=["-O3"])
cblas_libs, blas_info = get_blas_info()
eca = blas_info.pop('extra_compile_args', [])
eca.append("-O4")
config.add_extension("_barnes_hut_tsne",
libraries=cblas_libs,
sources=["_barnes_hut_tsne.c"],
include_dirs=[join('..', 'src', 'cblas'),
numpy.get_include(),
blas_info.pop('include_dirs', [])],
extra_compile_args=eca, **blas_info)
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('sparsetools', parent_package, top_path)
config.add_extension('_traversal',
sources=['_traversal.c'],
include_dirs=[numpy.get_include()],
#libraries=libraries
)
config.add_extension('_graph_tools',
sources=['_graph_tools.c'],
include_dirs=[numpy.get_include()],
#libraries=libraries
)
return config
def __getitem__(self, key):
if key != 'build_ext':
return super(LazyBuildExtCommandClass, self).__getitem__(key)
from Cython.Distutils import build_ext as cython_build_ext
import numpy
# Cython_build_ext isn't a new-style class in Py2.
class build_ext(cython_build_ext, object):
"""
Custom build_ext command that lazily adds numpy's include_dir to
extensions.
"""
def build_extensions(self):
"""
Lazily append numpy's include directory to Extension includes.
This is done here rather than at module scope because setup.py
may be run before numpy has been installed, in which case
importing numpy and calling `numpy.get_include()` will fail.
"""
numpy_incl = numpy.get_include()
for ext in self.extensions:
ext.include_dirs.append(numpy_incl)
super(build_ext, self).build_extensions()
return build_ext
def run(self):
# Make sure the compiled Cython files in the distribution are up-to-date
from Cython.Build import cythonize
cythonize(['polo.pyx'], include_dirs=[numpy.get_include()])
_sdist.run(self)
def run(word_gen, index, window_size, out_file):
context = []
pair_counts = Counter()
for word in word_gen:
context.append(index[word])
if len(context) > window_size * 2 + 1:
context.pop(0)
pair_counts = _process_context(context, pair_counts, window_size)
import pyximport
pyximport.install(setup_args={"include_dirs": np.get_include()})
from representations import sparse_io
sparse_io.export_mat_from_dict(pair_counts, out_file)
def load_matrix(f):
if not f.endswith('.bin'):
f += ".bin"
import pyximport
pyximport.install(setup_args={"include_dirs": np.get_include()})
from representations import sparse_io
return sparse_io.retrieve_mat_as_coo(f).tocsr()
def test_include_dirs(self):
# As a sanity check, just test that get_include
# includes something reasonable. Somewhat
# related to ticket #1405.
include_dirs = [np.get_include()]
for path in include_dirs:
assert_(isinstance(path, (str, unicode)))
assert_(path != '')
def get_include():
"""
Return the directory that contains the NumPy \\*.h header files.
Extension modules that need to compile against NumPy should use this
function to locate the appropriate include directory.
Notes
-----
When using ``distutils``, for example in ``setup.py``.
::
import numpy as np
...
Extension('extension_name', ...
include_dirs=[np.get_include()])
...
"""
import numpy
if numpy.show_config is None:
# running from numpy source directory
d = os.path.join(os.path.dirname(numpy.__file__), 'core', 'include')
else:
# using installed numpy core headers
import numpy.core as core
d = os.path.join(os.path.dirname(core.__file__), 'include')
return d
def get_numpy_include_dirs():
# numpy_include_dirs are set by numpy/core/setup.py, otherwise []
include_dirs = Configuration.numpy_include_dirs[:]
if not include_dirs:
import numpy
include_dirs = [ numpy.get_include() ]
# else running numpy/core/setup.py
return include_dirs
def finalize_options(self):
super().finalize_options()
import numpy
import pybind11
self.include_dirs.extend([
numpy.get_include(),
pybind11.get_include(user=True),
pybind11.get_include(),
])
def run(self):
"""Overridden method. Runs the build.
Library directories and include directories are checked here, first.
"""
# Add the numpy include directory.
self.include_dirs.insert(0, get_include())
# Call the base class method.
build_ext.run(self)
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def __getitem__(self, key):
if key != 'build_ext':
return super(LazyBuildExtCommandClass, self).__getitem__(key)
from Cython.Distutils import build_ext as cython_build_ext
import numpy
# Cython_build_ext isn't a new-style class in Py2.
class build_ext(cython_build_ext, object):
"""
Custom build_ext command that lazily adds numpy's include_dir to
extensions.
"""
def build_extensions(self):
"""
Lazily append numpy's include directory to Extension includes.
This is done here rather than at module scope because setup.py
may be run before numpy has been installed, in which case
importing numpy and calling `numpy.get_include()` will fail.
"""
numpy_incl = numpy.get_include()
for ext in self.extensions:
ext.include_dirs.append(numpy_incl)
super(build_ext, self).build_extensions()
return build_ext
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration("wrapper", parent_package, top_path)
try:
import build_info
except ImportError:
build_info = None
if build_info is None:
config.set_options(ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True)
return config
from Cython.Build import cythonize
import numpy
cythonize(cython_path("_wrapper.pyx"), language="c++")
# CMake outputs multiple include dirs separated by ";"
# but the setup scripts needs it as list => split it
config.add_extension(
'_wrapper',
sources=["_wrapper.cpp"], # Generated by cythonize
include_dirs=[".",
numpy.get_include(),
build_info.BOLERO_INCLUDE_DIRS.split(";"),
build_info.BL_LOADER_INCLUDE_DIRS.split(";"),
build_info.LIB_MANAGER_INCLUDE_DIRS.split(";")],
libraries=["bl_loader", "lib_manager"],
library_dirs=[build_info.BL_LOADER_LIBRARY_DIRS.split(";"),
build_info.LIB_MANAGER_LIBRARY_DIRS.split(";")],
define_macros=[("NDEBUG",)],
extra_compile_args=["-O3", "-Wno-unused-function",
"-Wno-unused-but-set-variable",])
return config
def ext_modules():
import numpy
walks_ext = Extension('jwalk.walks', ['jwalk/src/walks.pyx'],
include_dirs=[numpy.get_include()])
return [walks_ext]
def extensions():
from numpy import get_include
from Cython.Build import cythonize
ext_core = Extension(
"pydpc.core",
sources=["ext/core.pyx", "ext/_core.c"],
include_dirs=[get_include()],
extra_compile_args=["-O3", "-std=c99"])
exts = [ext_core]
return cythonize(exts)
def test_include_dirs(self):
# As a sanity check, just test that get_include
# includes something reasonable. Somewhat
# related to ticket #1405.
include_dirs = [np.get_include()]
for path in include_dirs:
assert_(isinstance(path, (str, unicode)))
assert_(path != '')
