emacs28

First author here. The hardware architectures are realistic - we developed & evaluated real example hardware implementations for them, validated on FPGA, and they achieved state-of-the-art ResNet performance in a deep learning accelerator system implementation compared to prior accelerators evaluated on similar FPGAs. See the associated accelerator system source code here:

https://github.com/trevorpogue/algebraic-nnhw

The hardware architectures focused on in the paper are systolic array designs, an efficient type of hardware design for matrix multiplication (e.g., the Google TPU uses this), as opposed to more SIMD-like vector architectures like GPUs. It may be possible to extend the proposed KMM algorithm to other types of hardware architectures also in future work. Regarding floating point - this work is applicable for integer matrix multiplication acceleration, it may be possible to extend the concept to floating point data types in future work also.

It produces identical/bit-equivalent results as conventional/naive matrix multiplication for integer/fixed-point data types

For everyone discussing the reduced accuracy/numerical stability of the algorithms in floating-point, this is true. But note that the application of the algorithms in the work is explored for fixed-point MM/quantized integer NN inference, not floating-point MM/inference. Hence, there is no reduction in accuracy for that application of it compared to using conventional fixed-point MM.

> you have to build hardware that matches the dimensions of the algorithm

Yes the benefits are realized in custom hardware designs as opposed to software, however, the hardware architectures work for multiplying matrices of arbitrary dimensions by splitting up larger matrices into smaller tiles, then summing up the tile products to form the final larger matrix products (i.e. GEMM)

Thanks, good summary. Regarding numerical stability, the application is for fixed-point arithmetic, and therefore numerical stability is not an issue (the result is identical compared to using the conventional inner-product)

IMHO, for fixed-point MM accelerators, there is no catch, I think it's an overlooked algorithm. It's based on an algorithm by Winograd who coincidentally also proposed another unrelated algorithm that later became very popular for CNN acceleration which would take some visibility away from this other algorithm by Winograd... But that is speculative

Personally I love my overpriced Samsung z fold, I don't use a laptop anymore (just a desktop), I can easily read double-column research articles wherever I am, it's great for drawing diagrams, and all of that without having to remember both your phone and a tablet everywhere you go.

CCX stands for Core Complex

CCD stands for Core Complex Die (neither terms refer to the IO die)

This can be resolved by changing the cells' format from General to Text. This makes the cells display the text exactly as entered. Select the relevant cells -> right click on them -> Format Cells... -> Text -> Ok

One good approach could be to base the architecture on the TPU v1 from [1]. There are also open-source accelerators you could get inspiration from, for example [2][3]. If you want to do less work/not hand code the RTL yourself then you could look into methods for automatically mapping OpenCL to an FPGA accelerator architecture (or a service like [3] provides pre-designed architectures for multiple FPGAs).

[1] https://arxiv.org/abs/1704.04760

[2] https://github.com/jofrfu/tinyTPU

[3] https://github.com/tensil-ai/tensil

The best productivity hack is to get a keyboard with programmable QMK firmware and remap the keys however/wherever you want.

When in Emacs I use a custom command that converts lowercase underscore-separated words to uppercase after typing the word out in lowercase so I don't have to use shift or capslock.

Yeah I haven't seen it done elsewhere, but I started doing that because those 2 inside keys on the third row are where my thumbs sit naturally if fully rest my hands.

I'm down to a 32-key layout, you can see my layout here

https://configure.zsa.io/moonlander/layouts/wyyxP/latest/0

(The layout currently has more than 32 keys due to extra function keys on the sides and modifiers on the bottom that I only use very rarely. I also no longer use the top pinky keys anymore.)

I have a vim-inspired modal mapping with three main modes: normal (navigation with arrows, pgup/dn, tab switching, etc.), mouse (to move the mouse), and qwerty (for typing). There is one always-present key for each mode that is dedicated only to switching permanently to that mode. These keys are on each of my thumbs, and the third on my right pinky. Each mode also has several unique (and some shared) temporary layers accessible by temporarily holding other keys.

I use a moonlander keyboard but my thumbs sit on the inside keys on the third row, and my palms on the top larger keys that are intended to be used for thumbs.

> Do you have a CI badge to show build/test status? This signal would better reach important parties by emailing maintainers or automatically creating an issue.

I find a CI and coverage badge worthwhile because they provide a quick reassurance that the project at least has some form of test plan, which immediately distinguishes it from many other repos.

There is a standardized API for package tools to expose and invoke editable-install functionality [1] which pip install follows, but Poetry didn't implement this API before (I see it does now though as of this past February [2]).

In other words, this a more thorough explanation of my point from [3]:

> Yes, if you ran poetry install you could get editable mode, but that requires every single end user of your package to install poetry and explicitly invoke a poetry install just for your package. And if someone else's package uses a different package builder, now they need to install and invoke that one. And on and on, and you end up with a six-hundred-line install script because of all the one-off "must install this developer's favorite package manager to use their package" stuff.

[1] https://peps.python.org/pep-0660/

[2] https://github.com/python-poetry/poetry/issues/34#issuecomme...

[3] https://www.reddit.com/r/Python/comments/t3p3ub/comment/hyum...

What I mean is `pip install -e` installs it outside of the virtual environment also.