Python-Extension | Python extension for NetLogo | Machine Learning library

I suggest you try like this:

• in root, create a directory src and move code.py into it

• create an empty __init__.py file in both test and src directories

• in your test_code.py file, try replacing:

  • from ..code import func
  • with from src.code import func

• make sure root is the current working directory

Now, you should be able to run your script from VS code and running pytest . from your terminal should also work.

You can embed Python code directly into NetLogo code using the Python extension, it is not usable only through the command center. Check out the Python Basic Example and Python Flocking Clusters models that come with NetLogo in the models library.

Here is the code from the Python Basic Example model:

The directory where setuptools looks for the compiled module can be obtained by build_ext.get_ext_fullpath(ext.name). In the above code the resulting path is passed to CMake by setting the variable CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE.

Since f2py is invoked through a custom command, the extension module is not automatically copied to the output directory. This can be achieved by another call to add_custom_command:

I finally solved it by uninstalling VS Code, deleting all configuration files and reinstalling.

Now when i have opened a python file and the current workspace contains a settings file with the correct python-interpreter the correct environment gets sourced.

You have to undefine DEBUG or _DEBUG, can't remember, around the python.h include in your code, since Python is linked with pragma directives. So it has nothing to do with cmake.

Something like this

Each time you do inp_tf[0][0] or inp_tf[0][1] you are creating a new tensor, but that new tensor is not used as input to your model, inp_tf is. Even if inp_tf[0][0] if part of inp_tf, from the point of view of TensorFlow there is no computation graph between your newly created inp_tf[0][0] and f, hence there is no gradient. You have to compute the gradient with respect to inp_tf and then take the parts of the gradient that you want from there.

In addition to that, as shown in the documentation of tf.GradientTape, you can use nested tapes to compute second order derivatives. And, if you use the jacobian, you can avoid using persistent=True, which is better for performance. Here is how it could work in your example (I changed the layer activation functions to sigmoid, as the default linear activation would not have a second order derivative).

Actually you don't need to implement Input in the call method as you are passing data directly to the subclass. I updated the code and it works well as expected. Please check below.

Usually distutils/setuptools don't use the linker directly, but call a frontend like gcc for c-extensions or g++ for c++-extensions.

These frontends collect all necessary information - like which libraries should be passed to the linker, e.g. libstdc++ for c++-extensions, - and call the linker with right command line options. One can see it when passing -v-option to the gcc- of g++-frontend for example via extra_link_args in setup.py.

So if you force distutuls/setuptools.py to use ld directly you also should provide all the options collected by the frontend in extra_link_args, otherwise some libraries will be missing and and compilation will fail, as you see.

It's quite difficult to let the setup.py to choose another linker, yet there are some cheap options to do it locally:

1. The default linker (e.g. /usr/bin/ld) is just a symlink, let it point to the linker of your choice.
2. Passing -B-option via extra_link_args, i.e. -B/path/to/folder/with/my/linker. The subtle details are: 1) the linker should be called ld (create a symlink if needed) 2) some distribution (e.g. Anaconda) allready provide a -B-option, which takes predecence over the path passed via extra_link_args. In this case one possible solution would be to modify emitted command line similar as described in this SO-post.
3. set the linker directly via LDSHARED environment variable and provide all needed options in extra_link_args.

Option 2 is probably easiest to tweak to work on any system:

1. detect if ld.lld is presend, if yes:
2. create a temporary folder with a symlink to it (called ld)
3. add this temp-folder as -B-options to extra_link_args
4. detect whether the distribution already uses -B option, manipulate command line (as described here for example) to ensure the precedence of the temp-folder.

I answer my own question.

I actually found the flaw in my code.

Both functions PyCapsule_GetPointer and PyCapsule_New work perfectly fine. As mentioned in my question, the issue arouse just after I was trying to Parse the capsule with the following code: