On Wednesday, 12 June 2024 at 17:00:14 UTC, Vinod K Chandran wrote:

It is probably not that well maintained, but it definitely works with python 3.10 and maybe even 3.11, i use it to interface with pytorch and numpy and PIL, but my use case is pretty simple, i just write some wrapper python functions to run inference and pass images back and forth using embedded py_stmts. the only problem is that it seems to leak a lot PydObjects so i have to manually free them, even scope doesn't helps with that which is sad.

example classifier python

def inference(image: Image):
    """ Predicts the image class and returns confidences for every class
    To get the class one can use the following code
    > conf = inference(image)
    > index = conf.argmax()
    > cls = classes[index]
    """

    # this detector doesn't works with more than 3 channels
    ch = len(image.getbands())
    has_transparency = image.info.get('transparency', None) is not None
    if ch > 3 or has_transparency:
        image = image.convert("RGB")

    image_tensor = prep_transform(image).float()
    image_tensor = image_tensor.unsqueeze_(0)

    # it is fast enough to run on CPU
    #if torch.cuda.is_available():
    #    image_tensor.cuda()

    with torch.inference_mode():
        # NOTE: read the comment on model
        output = model(image_tensor)
    index = output.data.numpy()

    return index

and some of D functions

ImageData aiGoesBrrrr(string path, int strength = 50) {
    try {
        if (!pymod)
            py_stmts("import sys; sys.path.append('modules/xyz')");
        initOnce!pymod(py_import("xyz.inference"));
        if (!pymod.hasattr("model"))
            pymod.model = pymod.method("load_model", "modules/xyz/pre_trained/weights.pth");

        PydObject ipath = py(path);
        scope(exit) destroy(ipath);

        auto context = new InterpContext();
        context.path = ipath;

        context.py_stmts("
        from PIL import Image
        image = Image.open(path)
        ch = len(image.getbands())
        if ch > 3:
            image = image.convert('RGB')
        ");

        // signature: def run(model, imagepath, alpha=45) -> numpy.Array
        PydObject output = pymod.method("run", pymod.model, context.image, 100-strength);
        context.output = output;
        scope(exit) destroy(output);

        PydObject shape = output.getattr("shape");
        scope(exit) destroy(shape);

        // int n = ...;
        int c = shape[2].to_d!int;
        int w = shape[1].to_d!int;
        int h = shape[0].to_d!int;

        // numpy array
        void* raw_ptr = output.buffer_view().item_ptr([0,0,0]);

        ubyte* d_ptr = cast(ubyte*) raw_ptr;
        ubyte[] d_img = d_ptr[0..h*w*c];

        return ImageData(d_img.dup, h ,w ,c);
    } catch (PythonException e) {
        // oh no...
        auto context = new InterpContext();
        context.trace = new PydObject(e.traceback);
        context.py_stmts("from traceback import format_tb; trace = format_tb(trace)");
        printerr(e.py_message, "\n", context.trace.to_d!string);
    }
    return ImageData.init;

On Wednesday, 12 June 2024 at 18:58:49 UTC, evilrat wrote:

You can use libonnx via importc to do inference of pytorch models after converting them *.onnx. in this way you won't need python at all. Please refer to the etichetta. instead of PIL for preprocessing just use DCV.

https://github.com/trikko/etichetta

On Wednesday, 12 June 2024 at 18:58:49 UTC, evilrat wrote:

Oh I see. I did some experiments with nimpy and pybind11. Both experiments were resulted in slower than ctypes dll calling method. That's why I didn't take much interest in binding with Python C API. Even Cython is slower compare to ctypes. But it can be used when we call the dll in Cython and call the cython code from python. But then you will have to face some other obstacles. In my case, callback functions are the reason. When using a dll in cython, you need to pass a cython function as callback and inside that func, you need to convert everything into pyobject back and forth. That will take time. Imagine that you want to do some heavy lifting in a mouse move event ? No one will be happy with at snail's pace.
But yeah, Cython is a nice language and we can create an entire gui lib in Cython but the execution speed is 2.5X slower than my current c3 dll.

On Wednesday, 12 June 2024 at 18:57:41 UTC, bachmeier wrote:

We can use it like this, i think.

struct Foo {
  double * ptr;
  uint capacity;
  uint legnth;
  alias data this;

}

And then we use an index, we can perform a bound check.
I am not sure but I hope this will work.

On Wednesday, 12 June 2024 at 20:31:34 UTC, Vinod K Chandran wrote:

struct Foo {
  double * ptr;
  uint capacity;
  uint legnth;
  alias data this;

}

Yes, you can do that, but then you're replicating what you get for free by taking a slice. You'd have to write your own opIndex, opSlice, etc., and I don't think there's any performance benefit from doing so.

On Wednesday, 12 June 2024 at 20:37:36 UTC, drug007 wrote:

import std;
import core.stdc.stdlib;

struct Foo {
  double[] data;
  double * ptr;
  alias data this;

  @nogc this(int n) {
    ptr = cast(double*) malloc(n*double.sizeof);
    data = ptr[0..n];
    printf("Data has been allocated\n");
  }
 }

Yes, but you get all the benefits of double[] for free if you do it that way, including the more concise foo[10] syntax.

On Wednesday, 12 June 2024 at 21:36:30 UTC, Dukc wrote:

Why would it be different from calling malloc and free manually? I guess I'm not understanding, because you put the same calls to malloc and free that you'd otherwise be doing inside this and ~this.