blog/2023-07-17-rust-or-mojo-ai

[giscus[bot]]

blog/2023-07-17-rust-or-mojo-ai

Learning Resources for Mojo 🔥

https://mojodojo.dev/blog/2023-07-17-rust-or-mojo-ai.html

[gryznar]

This article shows very well how much handy Mojo could be if it will gain desirable popularity :)

[gryznar]

Breakthrough may come if Mojo will release compiler for local development and people start play with it :)

[gryznar]

It's kinda impressive that this algorithm, wich was quite fast to implement is 3x faster than C++ version

[gryznar]

Also I am not sure if it is a bug or intentional behavior , but if I am logged in to chat via GitHub I don't see this conversation on page. If I am not logged, everything is OK

[mojodojodev]

Interesting @gryznar, I'm not seeing the same behavior on different browsers, if you get a chance log an issue with screenshots of the problem and I'll look into it

[gryznar]

Sure

Edit: I have checked again. Probably temporary problem related to delay in loading. Works well! ;)

[abduld]

Very nice blog post. The speedup is amazing!!! I have a few minor suggestions:

1. In place of

    var ix = x + kx
    if ix < 0: ix = 0
    ...
    if ix >= width: ix = width -1

you could write the code as

    let ix = clamp(x + kx, 0, width-1)

With clamp defined in the Math module

2. You could get away with using 255 instead of SIMD[DType.uint32, simd_width](255)

3. I suggest using vectorize in place of for x in range(0, width, simd_width): . The vectorize call will handle images that are not a multiple of simd_width.

4. Currently, you compute the average value for each patch of the image (so $(2*radius-1)^2$ for each output pixel). But if you look at the box filter you can cheat a little bit and only compute 3 elements (on average) for each output pixel. To show that consider the 1D problem which can be written in Python as

def moving_average(lst, window_size):
    averages = []
    for idx in range(window_size, len(lst) - window_size):
       mean = sum(lst[idx : idx + window_size]) / window_size
       averages.append(mean)

Notice that here for each output element, we are computing the sum of a window_size vector, but you can simplify the above by noticing that the middle elements are all shared so the above can be rewritten as (modulo some off-by-one errors)

def moving_average(lst, window_size):
    curr = sum(lst[:window_size])
    averages = [curr / window_size]
    for idx, elem in enumerate(lst[window_size+1:-window_size]):
       curr = curr - lst[idx] + elem
       averages.append(curr / window_size)

So at each iteration, you only need to subtract the element that just went outside your window and then add the one that was just added to your window.

The same can be done to your box filter where you need to subtract the column that just went outside your window and add the one that just went into your window --- thus reducing the computation to $2*(2radius-1)$ compared to $(2radius-1)^2$.

A more advanced optimization would take advantage of the box filter being separable ... but that goes into that mathy side of things.

5. For the numpy_data_pointer, we should add a static method called from_address to DTypePointer so that the code becomes a lot simpler.

[mojodojodev]

Thanks so much for all these suggestions and information super appreciated! I've addressed 1,2,3 and 5, still working on the moving average haven't quite figured it out yet but that will definitely speed it up a lot more.

[BoBoat1]

I think modular should hire more great engineers if you want to speed up this process because mojo have the potential to become the most important programming language in the world if what you claim is right

[gryznar]

More people not always mean better progress. :) Currently Modular is adding new features to Mojo with a nice rate :)

[mojodojodev]

You can check out their team here it's impressive, they have open roles as well

[gryznar]

This code could be also placed in a benchmarks section :)