Missing compiler executables on import

[hectormz]

Importing aeppl (or importing pymc4) results in a list of executables that cannot be found:

Could not locate executable g77
Could not locate executable f77
Could not locate executable ifort
Could not locate executable ifl
Could not locate executable f90
Could not locate executable efl
Could not locate executable gfortran
Could not locate executable f95
Could not locate executable g95
Could not locate executable efort
Could not locate executable efc
Could not locate executable flang
don't know how to compile Fortran code on platform 'nt'

Do you know which dependency is producing these messages and if they are warnings or errors?

Versions and main components

• Aesara version: 2.5.1
• Aesara config

WARNING (aesara.tensor.blas): Using NumPy C-API based implementation for BLAS functions.
floatX ({'float16', 'float64', 'float32'})
    Doc:  Default floating-point precision for python casts.

Note: float16 support is experimental, use at your own risk.
    Value:  float64

warn_float64 ({'warn', 'ignore', 'pdb', 'raise'})
    Doc:  Do an action when a tensor variable with float64 dtype is created. They can't be run on the GPU with the current(old) gpu back-end and are slow with gamer GPUs.
    Value:  ignore

pickle_test_value (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288E0C39820>>)
    Doc:  Dump test values while pickling model. If True, test values will be dumped with model.
    Value:  True

cast_policy ({'custom', 'numpy+floatX'})
    Doc:  Rules for implicit type casting
    Value:  custom

deterministic ({'default', 'more'})
    Doc:  If `more`, sometimes we will select some implementation that are more deterministic, but slower. In particular, on the GPU, we will avoid using AtomicAdd. Sometimes we will still use non-deterministic implementation, e.g. when we do not have a GPU implementation that is deterministic. Also see the dnn.conv.algo* flags to cover more cases.
    Value:  default

device (cpu, opencl*, cuda*)
    Doc:  Default device for computations. If cuda* or opencl*, change thedefault to try to move computation to the GPU. Do not use upper caseletters, only lower case even if NVIDIA uses capital letters. 'gpu' means let the driver select the gpu (needed for gpu in exclusive mode). 'gpuX' mean use the gpu number X.
    Value:  cpu

init_gpu_device (, opencl*, cuda*)
    Doc:  Initialize the gpu device to use, works only if device=cpu. Unlike 'device', setting this option will NOT move computations, nor shared variables, to the specified GPU. It can be used to run GPU-specific tests on a particular GPU.
    Value:

force_device (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8F6BDF0>>)
    Doc:  Raise an error if we can't use the specified device
    Value:  False

conv__assert_shape (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8F6B6A0>>)
    Doc:  If True, AbstractConv* ops will verify that user-provided shapes match the runtime shapes (debugging option, may slow down compilation)
    Value:  False

print_global_stats (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8F6BA60>>)
    Doc:  Print some global statistics (time spent) at the end
    Value:  False

<aesara.configparser.ContextsParam object at 0x00000288F8F6BB80>
    Doc:
        Context map for multi-gpu operation. Format is a
        semicolon-separated list of names and device names in the
        'name->dev_name' format. An example that would map name 'test' to
        device 'cuda0' and name 'test2' to device 'opencl0:0' follows:
        "test->cuda0;test2->opencl0:0".

        Invalid context names are 'cpu', 'cuda*' and 'opencl*'

    Value:

print_active_device (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8F6BB20>>)
    Doc:  Print active device at when the GPU device is initialized.
    Value:  True

gpuarray__preallocate (<class 'float'>)
    Doc:  If negative it disables the allocation cache. If
                 between 0 and 1 it enables the allocation cache and
                 preallocates that fraction of the total GPU memory.  If 1
                 or greater it will preallocate that amount of memory (in
                 megabytes).
    Value:  0.0

gpuarray__sched ({'default', 'single', 'multi'})
    Doc:  The sched parameter passed for context creation to pygpu.
                    With CUDA, using "multi" is equivalent to using the parameter
                    cudaDeviceScheduleBlockingSync. This is useful to lower the
                    CPU overhead when waiting for GPU. One user found that it
                    speeds up his other processes that was doing data augmentation.

    Value:  default

gpuarray__single_stream (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FA7BB0>>)
    Doc:
                 If your computations are mostly lots of small elements,
                 using single-stream will avoid the synchronization
                 overhead and usually be faster.  For larger elements it
                 does not make a difference yet.  In the future when true
                 multi-stream is enabled in libgpuarray, this may change.
                 If you want to make sure to have optimal performance,
                 check both options.

    Value:  True

cuda__root (<class 'str'>)
    Doc:  Location of the cuda installation
    Value:

cuda__include_path (<class 'str'>)
    Doc:  Location of the cuda includes
    Value:

assert_no_cpu_op ({'warn', 'ignore', 'pdb', 'raise'})
    Doc:  Raise an error/warning if there is a CPU op in the computational graph.
    Value:  ignore

unpickle_function (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FA7CD0>>)
    Doc:  Replace unpickled Aesara functions with None. This is useful to unpickle old graphs that pickled them when it shouldn't
    Value:  True

reoptimize_unpickled_function (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FA7D30>>)
    Doc:  Re-optimize the graph when an Aesara function is unpickled from the disk.
    Value:  False

dnn__conv__algo_fwd ({'small', 'winograd', 'guess_on_shape_change', 'winograd_non_fused', 'guess_once', 'time_on_shape_change', 'large', 'fft', 'none', 'time_once', 'fft_tiling'})
    Doc:  Default implementation to use for cuDNN forward convolution.
    Value:  small

dnn__conv__algo_bwd_data ({'winograd', 'guess_on_shape_change', 'time_once', 'winograd_non_fused', 'guess_once', 'time_on_shape_change', 'fft', 'none', 'deterministic', 'fft_tiling'})
    Doc:  Default implementation to use for cuDNN backward convolution to get the gradients of the convolution with regard to the inputs.
    Value:  none

dnn__conv__algo_bwd_filter ({'small', 'guess_on_shape_change', 'winograd_non_fused', 'guess_once', 'time_on_shape_change', 'fft', 'none', 'time_once', 'fft_tiling', 'deterministic'})
    Doc:  Default implementation to use for cuDNN backward convolution to get the gradients of the convolution with regard to the filters.
    Value:  none

dnn__conv__precision ({'as_input', 'as_input_f32', 'float64', 'float16', 'float32'})
    Doc:  Default data precision to use for the computation in cuDNN convolutions (defaults to the same dtype as the inputs of the convolutions, or float32 if inputs are float16).
    Value:  as_input_f32

dnn__base_path (<class 'str'>)
    Doc:  Install location of cuDNN.
    Value:

dnn__include_path (<class 'str'>)
    Doc:  Location of the cudnn header
    Value:

dnn__library_path (<class 'str'>)
    Doc:  Location of the cudnn link library.
    Value:

dnn__bin_path (<class 'str'>)
    Doc:  Location of the cuDNN load library (on non-windows platforms, this is the same as dnn__library_path)
    Value:

dnn__enabled ({'auto', 'False', 'no_check', 'True'})
    Doc:  'auto', use cuDNN if available, but silently fall back to not using it if not present. If True and cuDNN can not be used, raise an error. If False, disable cudnn even if present. If no_check, assume present and the version between header and library match (so less compilation at context init)
    Value:  auto

magma__include_path (<class 'str'>)
    Doc:  Location of the magma header
    Value:

magma__library_path (<class 'str'>)
    Doc:  Location of the magma library
    Value:

magma__enabled (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9100>>)
    Doc:   If True, use magma for matrix computation. If False, disable magma
    Value:  False

<aesara.configparser.ConfigParam object at 0x00000288F8FB90D0>
    Doc:  Default compilation mode
    Value:  Mode

cxx (<class 'str'>)
    Doc:  The C++ compiler to use. Currently only g++ is supported, but supporting additional compilers should not be too difficult. If it is empty, no C++ code is compiled.
    Value:  "C:\Users\XXX\scoop\apps\gcc\current\bin\g++.exe"

linker ({'cvm', 'c', 'c|py', 'cvm_nogc', 'vm_nogc', 'c|py_nogc', 'vm', 'py'})
    Doc:  Default linker used if the aesara flags mode is Mode
    Value:  cvm

allow_gc (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9460>>)
    Doc:  Do we default to delete intermediate results during Aesara function calls? Doing so lowers the memory requirement, but asks that we reallocate memory at the next function call. This is implemented for the default linker, but may not work for all linkers.
    Value:  True

optimizer ({'o1', 'unsafe', 'fast_run', 'merge', 'None', 'o2', 'o3', 'o4', 'fast_compile'})
    Doc:  Default optimizer. If not None, will use this optimizer with the Mode
    Value:  o4

optimizer_verbose (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9190>>)
    Doc:  If True, we print all optimization being applied
    Value:  False

on_opt_error ({'warn', 'ignore', 'pdb', 'raise'})
    Doc:  What to do when an optimization crashes: warn and skip it, raise the exception, or fall into the pdb debugger.
    Value:  warn

nocleanup (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9310>>)
    Doc:  Suppress the deletion of code files that did not compile cleanly
    Value:  False

on_unused_input ({'raise', 'ignore', 'warn'})
    Doc:  What to do if a variable in the 'inputs' list of  aesara.function() is not used in the graph.
    Value:  raise

gcc__cxxflags (<class 'str'>)
    Doc:  Extra compiler flags for gcc
    Value:

cmodule__warn_no_version (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9430>>)
    Doc:  If True, will print a warning when compiling one or more Op with C code that can't be cached because there is no c_code_cache_version() function associated to at least one of those Ops.
    Value:  False

cmodule__remove_gxx_opt (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB92B0>>)
    Doc:  If True, will remove the -O* parameter passed to g++.This is useful to debug in gdb modules compiled by Aesara.The parameter -g is passed by default to g++
    Value:  False

cmodule__compilation_warning (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB93D0>>)
    Doc:  If True, will print compilation warnings.
    Value:  False

cmodule__preload_cache (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9370>>)
    Doc:  If set to True, will preload the C module cache at import time
    Value:  False

cmodule__age_thresh_use (<class 'int'>)
    Doc:  In seconds. The time after which Aesara won't reuse a compile c module.
    Value:  2073600

cmodule__debug (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9490>>)
    Doc:  If True, define a DEBUG macro (if not exists) for any compiled C code.
    Value:  False

compile__wait (<class 'int'>)
    Doc:  Time to wait before retrying to acquire the compile lock.
    Value:  5

compile__timeout (<class 'int'>)
    Doc:  In seconds, time that a process will wait before deciding to
    override an existing lock. An override only happens when the existing
    lock is held by the same owner *and* has not been 'refreshed' by this
    owner for more than this period. Refreshes are done every half timeout
    period for running processes.
    Value:  120

ctc__root (<class 'str'>)
    Doc:  Directory which contains the root of Baidu CTC library. It is assumed         that the compiled library is either inside the build, lib or lib64         subdirectory, and the header inside the include directory.
    Value:

tensor__cmp_sloppy (<class 'int'>)
    Doc:  Relax aesara.tensor.math._allclose (0) not at all, (1) a bit, (2) more
    Value:  0

tensor__local_elemwise_fusion (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9640>>)
    Doc:  Enable or not in fast_run mode(fast_run optimization) the elemwise fusion optimization
    Value:  True

lib__amblibm (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9700>>)
    Doc:  Use amd's amdlibm numerical library
    Value:  False

tensor__insert_inplace_optimizer_validate_nb (<class 'int'>)
    Doc:  -1: auto, if graph have less then 500 nodes 1, else 10
    Value:  -1

traceback__limit (<class 'int'>)
    Doc:  The number of stack to trace. -1 mean all.
    Value:  8

traceback__compile_limit (<class 'int'>)
    Doc:  The number of stack to trace to keep during compilation. -1 mean all. If greater then 0, will also make us save Aesara internal stack trace.
    Value:  0

experimental__unpickle_gpu_on_cpu (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9880>>)
    Doc:  Allow unpickling of pickled GpuArrays as numpy.ndarrays.This is useful, if you want to open a GpuArray without having cuda installed.If you have cuda installed, this will force unpickling tobe done on the cpu to numpy.ndarray.Please be aware that this may get you access to the data,however, trying to unpicke gpu functions will not succeed.This flag is experimental and may be removed any time, whengpu<>cpu transparency is solved.
    Value:  False

experimental__local_alloc_elemwise (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB98B0>>)
    Doc:  DEPRECATED: If True, enable the experimental optimization local_alloc_elemwise. Generates error if not True. Use optimizer_excluding=local_alloc_elemwise to disable.
    Value:  True

experimental__local_alloc_elemwise_assert (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9940>>)
    Doc:  When the local_alloc_elemwise is applied, add an assert to highlight shape errors.
    Value:  True

warn__ignore_bug_before ({'0.9', '1.0.5', '1.0.4', '0.8', '0.4.1', '0.8.2', '0.6', '1.0.3', '0.7', 'None', '1.0', '0.5', '0.3', '1.0.1', '0.8.1', '0.10', '1.0.2', 'all', '0.4'})
    Doc:  If 'None', we warn about all Aesara bugs found by default. If 'all', we don't warn about Aesara bugs found by default. If a version, we print only the warnings relative to Aesara bugs found after that version. Warning for specific bugs can be configured with specific [warn] flags.
    Value:  0.9

exception_verbosity ({'low', 'high'})
    Doc:  If 'low', the text of exceptions will generally refer to apply nodes with short names such as Elemwise{add_no_inplace}. If 'high', some exceptions will also refer to apply nodes with long descriptions  like:
        A. Elemwise{add_no_inplace}
                B. log_likelihood_v_given_h
                C. log_likelihood_h
    Value:  low

print_test_value (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9A30>>)
    Doc:  If 'True', the __eval__ of an Aesara variable will return its test_value when this is available. This has the practical conseguence that, e.g., in debugging `my_var` will print the same as `my_var.tag.test_value` when a test value is defined.
    Value:  False

compute_test_value ({'warn', 'raise', 'ignore', 'pdb', 'off'})
    Doc:  If 'True', Aesara will run each op at graph build time, using Constants, SharedVariables and the tag 'test_value' as inputs to the function. This helps the user track down problems in the graph before it gets optimized.
    Value:  off

compute_test_value_opt ({'warn', 'raise', 'ignore', 'pdb', 'off'})
    Doc:  For debugging Aesara optimization only. Same as compute_test_value, but is used during Aesara optimization
    Value:  off

check_input (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9A90>>)
    Doc:  Specify if types should check their input in their C code. It can be used to speed up compilation, reduce overhead (particularly for scalars) and reduce the number of generated C files.
    Value:  True

NanGuardMode__nan_is_error (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9AC0>>)
    Doc:  Default value for nan_is_error
    Value:  True

NanGuardMode__inf_is_error (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9B20>>)
    Doc:  Default value for inf_is_error
    Value:  True

NanGuardMode__big_is_error (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9BB0>>)
    Doc:  Default value for big_is_error
    Value:  True

NanGuardMode__action ({'raise', 'pdb', 'warn'})
    Doc:  What NanGuardMode does when it finds a problem
    Value:  raise

DebugMode__patience (<class 'int'>)
    Doc:  Optimize graph this many times to detect inconsistency
    Value:  10

DebugMode__check_c (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9C40>>)
    Doc:  Run C implementations where possible
    Value:  True

DebugMode__check_py (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9CD0>>)
    Doc:  Run Python implementations where possible
    Value:  True

DebugMode__check_finite (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9CA0>>)
    Doc:  True -> complain about NaN/Inf results
    Value:  True

DebugMode__check_strides (<class 'int'>)
    Doc:  Check that Python- and C-produced ndarrays have same strides. On difference: (0) - ignore, (1) warn, or (2) raise error
    Value:  0

DebugMode__warn_input_not_reused (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9D30>>)
    Doc:  Generate a warning when destroy_map or view_map says that an op works inplace, but the op did not reuse the input for its output.
    Value:  True

DebugMode__check_preallocated_output (<class 'str'>)
    Doc:  Test thunks with pre-allocated memory as output storage. This is a list of strings separated by ":". Valid values are: "initial" (initial storage in storage map, happens with Scan),"previous" (previously-returned memory), "c_contiguous", "f_contiguous", "strided" (positive and negative strides), "wrong_size" (larger and smaller dimensions), and "ALL" (all of the above).
    Value:

DebugMode__check_preallocated_output_ndim (<class 'int'>)
    Doc:  When testing with "strided" preallocated output memory, test all combinations of strides over that number of (inner-most) dimensions. You may want to reduce that number to reduce memory or time usage, but it is advised to keep a minimum of 2.
    Value:  4

profiling__time_thunks (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9DC0>>)
    Doc:  Time individual thunks when profiling
    Value:  True

profiling__n_apply (<class 'int'>)
    Doc:  Number of Apply instances to print by default
    Value:  20

profiling__n_ops (<class 'int'>)
    Doc:  Number of Ops to print by default
    Value:  20

profiling__output_line_width (<class 'int'>)
    Doc:  Max line width for the profiling output
    Value:  512

profiling__min_memory_size (<class 'int'>)
    Doc:  For the memory profile, do not print Apply nodes if the size
                 of their outputs (in bytes) is lower than this threshold
    Value:  1024

profiling__min_peak_memory (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9F10>>)
    Doc:  The min peak memory usage of the order
    Value:  False

profiling__destination (<class 'str'>)
    Doc:  File destination of the profiling output
    Value:  stderr

profiling__debugprint (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9F70>>)

    Doc:  Do a debugprint of the profiled functions
    Value:  False

profiling__ignore_first_call (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FB9FA0>>)
    Doc:  Do we ignore the first call of an Aesara function.
    Value:  False

on_shape_error ({'warn', 'raise'})
    Doc:  warn: print a warning and use the default value. raise: raise an error
    Value:  warn

openmp (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0070>>)
    Doc:  Allow (or not) parallel computation on the CPU with OpenMP. This is the default value used when creating an Op that supports OpenMP parallelization. It is preferable to define it via the Aesara configuration file ~/.aesararc or with the environment variable AESARA_FLAGS. Parallelization is only done for some operations that implement it, and even for operations that implement parallelism, each operation is free to respect this flag or not. You can control the number of threads used with the environment variable OMP_NUM_THREADS. If it is set to 1, we disable openmp in Aesara by default.
    Value:  False

openmp_elemwise_minsize (<class 'int'>)
    Doc:  If OpenMP is enabled, this is the minimum size of vectors for which the openmp parallelization is enabled in element wise ops.
    Value:  200000

optimizer_excluding (<class 'str'>)
    Doc:  When using the default mode, we will remove optimizer with these tags. Separate tags with ':'.
    Value:

optimizer_including (<class 'str'>)
    Doc:  When using the default mode, we will add optimizer with these tags. Separate tags with ':'.
    Value:

optimizer_requiring (<class 'str'>)
    Doc:  When using the default mode, we will require optimizer with these tags. Separate tags with ':'.
    Value:

optdb__position_cutoff (<class 'float'>)
    Doc:  Where to stop eariler during optimization. It represent the position of the optimizer where to stop.
    Value:  inf

optdb__max_use_ratio (<class 'float'>)
    Doc:  A ratio that prevent infinite loop in EquilibriumOptimizer.
    Value:  8.0

cycle_detection ({'regular', 'fast'})
    Doc:  If cycle_detection is set to regular, most inplaces are allowed,but it is slower. If cycle_detection is set to faster, less inplacesare allowed, but it makes the compilation faster.The interaction of which one give the lower peak memory usage iscomplicated and not predictable, so if you are close to the peakmemory usage, triyng both could give you a small gain.
    Value:  regular

check_stack_trace ({'warn', 'raise', 'off', 'log'})
    Doc:  A flag for checking the stack trace during the optimization process. default (off): does not check the stack trace of any optimization log: inserts a dummy stack trace that identifies the optimizationthat inserted the variable that had an empty stack trace.warn: prints a warning if a stack trace is missing and also a dummystack trace is inserted that indicates which optimization insertedthe variable that had an empty stack trace.raise: raises an exception if a stack trace is missing
    Value:  off

metaopt__verbose (<class 'int'>)
    Doc:  0 for silent, 1 for only warnings, 2 for full output withtimings and selected implementation
    Value:  0

metaopt__optimizer_excluding (<class 'str'>)
    Doc:  exclude optimizers with these tags. Separate tags with ':'.
    Value:

metaopt__optimizer_including (<class 'str'>)
    Doc:  include optimizers with these tags. Separate tags with ':'.
    Value:

profile (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0310>>)
    Doc:  If VM should collect profile information
    Value:  False

profile_optimizer (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0370>>)
    Doc:  If VM should collect optimizer profile information
    Value:  False

profile_memory (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC03A0>>)
    Doc:  If VM should collect memory profile information and print it
    Value:  False

<aesara.configparser.ConfigParam object at 0x00000288F8FC03D0>
    Doc:  Useful only for the vm linkers. When lazy is None, auto detect if lazy evaluation is needed and use the appropriate version. If lazy is True/False, force the version used between Loop/LoopGC and Stack.
    Value:  None

unittests__rseed (<class 'str'>)
    Doc:  Seed to use for randomized unit tests. Special value 'random' means using a seed of None.
    Value:  666

warn__round (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0490>>)
    Doc:  Warn when using `tensor.round` with the default mode. Round changed its default from `half_away_from_zero` to `half_to_even` to have the same default as NumPy.
    Value:  False

numba__vectorize_target ({'cuda', 'parallel', 'cpu'})
    Doc:  Default target for numba.vectorize.
    Value:  cpu

numba__fastmath (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0580>>)
    Doc:  If True, use Numba's fastmath mode.
    Value:  True

numba__cache (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F8FC0610>>)
    Doc:  If True, use Numba's file based caching.
    Value:  True

compiledir_format (<class 'str'>)
    Doc:  Format string for platform-dependent compiled module subdirectory
(relative to base_compiledir). Available keys: aesara_version, device,
gxx_version, hostname, numpy_version, platform, processor,
python_bitwidth, python_int_bitwidth, python_version, short_platform.
Defaults to compiledir_%(short_platform)s-%(processor)s-%(python_versi
on)s-%(python_bitwidth)s.
    Value:  compiledir_%(short_platform)s-%(processor)s-%(python_version)s-%(python_bitwidth)s

<aesara.configparser.ConfigParam object at 0x00000288F8FC0A30>
    Doc:  platform-independent root directory for compiled modules
    Value:  C:\Users\XXX\AppData\Local\Aesara

<aesara.configparser.ConfigParam object at 0x00000288F8FC0A00>
    Doc:  platform-dependent cache directory for compiled modules
    Value:  C:\Users\XXX\AppData\Local\Aesara\compiledir_Windows-10-10.0.19043-SP0-Intel64_Family_6_Model_165_Stepping_2_GenuineIntel-3.9.12-64

<aesara.configparser.ConfigParam object at 0x00000288F8FC0A90>
    Doc:  Directory to cache pre-compiled kernels for the gpuarray backend.
    Value:  C:\Users\XXX\AppData\Local\Aesara\compiledir_Windows-10-10.0.19043-SP0-Intel64_Family_6_Model_165_Stepping_2_GenuineIntel-3.9.12-64\gpuarray_kernels

blas__ldflags (<class 'str'>)
    Doc:  lib[s] to include for [Fortran] level-3 blas implementation
    Value:

blas__check_openmp (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288F931F070>>)
    Doc:  Check for openmp library conflict.
WARNING: Setting this to False leaves you open to wrong results in blas-related operations.
    Value:  True

scan__allow_gc (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288924FBFD0>>)
    Doc:  Allow/disallow gc inside of Scan (default: False)
    Value:  False

scan__allow_output_prealloc (<bound method BoolParam._apply of <aesara.configparser.BoolParam object at 0x00000288924FBF10>>)
    Doc:  Allow/disallow memory preallocation for outputs inside of scan (default: True)
    Value:  True

• Python version: 3.9.12
• Operating system: Windows 10
• How did you install Aesara: pip

[rlouf]

Thank you for opening an issue. Do you have a fortran compiler on your machine?

[hectormz]

Hi @rlouf I don't believe I do. Is a fortran compiler required for use, or just for optimization? Do you have a suggestion you could add to the README?

[brandonwillard]

Looks like you might need to install a m2w64 toolchain in your environment. See the instructions here.

[hectormz]

Thanks @brandonwillard I do have gcc, would that suffice or I need more?

[brandonwillard]

The above numpy config doesn't mention mkl, so it seems that my install via conda didn't grab the mkl version, right?

I don't think any signs of MKL should necessarily appear in that NumPy config output, because, in most environments, the MKL libraries are symlinked via generic names liblapack*, libblas*, etc.

You might want to check those library directories NumPy provided and see if there are any such links, although I'm not sure whether or not it works the same way in Windows.

[hectormz]

Hi @brandonwillard ,I did some tests in virtual environments. The results below seem to indicate that (on Windows at least) you can tell if you have the mkl version of numpy. I am also not getting the mkl version of numpy and scipy from conda like I'm expecting when I install aesara/pymc.

Here is my np.show_config() for my vanilla python env:

blas_mkl_info: 
  NOT AVAILABLE
blis_info:     
  NOT AVAILABLE
openblas_info: 
    library_dirs = ['D:\\a\\1\\s\\numpy\\build\\openblas_info']
    libraries = ['openblas_info']
    language = f77
    define_macros = [('HAVE_CBLAS', None)]
blas_opt_info:
    library_dirs = ['D:\\a\\1\\s\\numpy\\build\\openblas_info']
    libraries = ['openblas_info']
    language = f77
    define_macros = [('HAVE_CBLAS', None)]
lapack_mkl_info:
  NOT AVAILABLE
openblas_lapack_info:
    library_dirs = ['D:\\a\\1\\s\\numpy\\build\\openblas_lapack_info']
    libraries = ['openblas_lapack_info']
    language = f77
    define_macros = [('HAVE_CBLAS', None)]
lapack_opt_info:
    library_dirs = ['D:\\a\\1\\s\\numpy\\build\\openblas_lapack_info']
    libraries = ['openblas_lapack_info']
    language = f77
    define_macros = [('HAVE_CBLAS', None)]
Supported SIMD extensions in this NumPy install:
    baseline = SSE,SSE2,SSE3
    found = SSSE3,SSE41,POPCNT,SSE42,AVX,F16C,FMA3,AVX2
    not found = AVX512F,AVX512CD,AVX512_SKX,AVX512_CLX,AVX512_CNL

Here is my np.show_config() for my aesara/pymc miniconda env:

blas_info:
    libraries = ['cblas', 'blas', 'cblas', 'blas', 'cblas', 'blas']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\lib']
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\include']
    language = f77
    define_macros = [('HAVE_CBLAS', None)]
blas_opt_info:
    define_macros = [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)]
    libraries = ['cblas', 'blas', 'cblas', 'blas', 'cblas', 'blas']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\lib']
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\include']
    language = f77
lapack_info:
    libraries = ['lapack', 'blas', 'lapack', 'blas']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\lib']
    language = f77
lapack_opt_info:
    libraries = ['lapack', 'blas', 'lapack', 'blas', 'cblas', 'blas', 'cblas', 'blas', 'cblas', 'blas']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\lib']
    language = f77
    define_macros = [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/pymc_env\\Library\\include']
Supported SIMD extensions in this NumPy install:
    baseline = SSE,SSE2,SSE3
    found = SSSE3,SSE41,POPCNT,SSE42,AVX,F16C,FMA3,AVX2
    not found = AVX512F,AVX512CD,AVX512_SKX,AVX512_CLX,AVX512_CNL

Here is my np.show_config() for my a new miniconda env where I've only run ((np_env) C:\Users\hectormz>conda install numpy):

blas_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\include']
blas_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\include']
lapack_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\include']
lapack_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/hectormz/Miniconda3/envs/np_env\\Library\\include']
Supported SIMD extensions in this NumPy install:
    baseline = SSE,SSE2,SSE3
    found = SSSE3,SSE41,POPCNT,SSE42,AVX,F16C,FMA3,AVX2
    not found = AVX512F,AVX512CD,AVX512_SKX,AVX512_CLX,AVX512_CNL

[hectormz]

Setting my .aesararc to:

[blas]
ldflags=-lmkl_rt

or

[blas]
ldflags=-lblas

doesn't seem to make a difference with errors, as long as I have one of them.

I would have guessed I would get a warning or error if I set the flag to lmkl_rt but actually only had openBLAS version

[brandonwillard]

These are all the same NumPy versions in each case?

[hectormz]

For vanilla python: 1.21.4, for the conda numpy env: 1.21.5 and for the aesara/pymc env it is 1.21.5

Since my last reply, I deleted my pymc conda env and remade it (seemingly with the same steps I listed above) and I now have the mkl version. So I can't explain that...

I guess I now don't have an issue at the moment, but want to confirm that I have the right mkl versions in both miniconda and vanilla python environments, and make sure I'm configuring aesara to use them properly.