pineapple_sauce

Why did you go with a publisher rather than publishing it yourself?

I believe KAN hype died off due to practical reasons (e.g. FLOPs from implementation) and empirical results, i.e. people reproduced KANs and they found the claims/results made in the original paper were misleading.

Here's a paper showing KANs are no better than MLPs, if anything they are typically worse when comparing fairly. https://arxiv.org/pdf/2407.16674

https://github.com/intel/intel-extension-for-pytorch

This appears to be a significantly better implementation. Tramp mode is god awful slow and does not maintain a persistent connection.

How is Jax theoretically better than PyTorch? The author is ignorant of torch.compile and biased as other commenters have pointed out.

"Meat produced" - why not just say it how it is? "Animals killed" ...

The last time I used MacPorts it fell out of popularity and did not have nearly as many packages as Homebrew had. It's unfortunate. Homebrew is dogshit slow.

On rasterization & basic typesetting (no ligatures/gsub lookups): check out pixie https://github.com/treeform/pixie

How do you measure beauty? You can't: "beauty" is subjective. And even if you try e.g. count the times you use recursion vs. iteration: that metric is subjective and not grounded in reality.

Sometimes recursion does allow you to reason about code more easily or come to a working solution faster, sometimes it does not.

Measure the concrete: CPU time and memory consumed. Iteration will likely trump recursive methods w.r.t both these metrics. If it doesn't, you can likely transform your iterative algorithm to one that utilizes SIMD (not always).

How is applying DRY entering premature optimization territory (maybe relative to LOC?)? I argue it is instead: premature abstraction.

Optimization is specialization (which is the opposite of DRY): to enable DRY you likely need to generalize the problem (i.e. abstract) such that you remove duplication.

Yes, I'm well aware of the definition of a macro in C and C++. Macros are simpler than templates. You can expand them with a compiler flag.

What should be evaluated is removing indirection and tightly packing your data. I'm sure you'll gain a better performance improvement. virtual calls and shared_ptr are littered in the codebase.

In this way: you can avoid the need for the `final` keyword and do the optimization the keyword enables (de-virtualize calls).

Yes, it is very hacky and I am disgusted by this myself. I would never do this in an actual product

Why? What's with the C++ community and their disgust for macros without any underlying reasoning? It reminds me of everyone blindly saying "Don't use goto; it creates spaghetti code".

Sure, if macros are overly used: it can be hard to read and maintain. But, for something simple like this, you shouldn't be thinking "I would never do this in an actual product".

Mojo is a programming language, this is a library for Python that provides an abstraction over three Python-specific ML frameworks. Apples and oranges.

You could use Keras inside of Mojo since Mojo is Python-compatible/embeds a Python interpreter.

Meta uses https://github.com/facebook/sapling see: https://engineering.fb.com/2022/11/15/open-source/sapling-so...

It’s an extension from Mercurial as the blog post states.

"blazingly fast"

written by homebrew author (brew is notoriously slow)

written in typescript

hmmm... I have my doubts on that claim, especially when there is no evidence to support it.

DPI is not correct on MacOS

Related: https://github.com/ansiwave/nimwave

I would be interested in how CLIP performs post quantization. This should be relatively simple to test via ImageNet zero-shot top-1 acc as one example metric.

From the Nim programming language community, this project is this feature: https://github.com/treeform/fidget

From what I can tell: 1. They have a REPL and Jupyter integration 2. They're planning to do C and C++ interop. This is achievable in Nim but it is a pain, i.e. there is not easy way to import/include a C header in Nim, e.g. nothing as straight-forward as @cImport("cheader.h") in Zig or #include "cheader.h" in C++; one must go through c2nim or a third-party library

(1) cannot be achieved without a custom linker or using a JIT such as LLVM or compiling to WASM and embedding a WASM runtime into the binary

I really hope Nim gets some language/compiler upgrades due to this.

Not sure how they compare, but: https://github.com/facebookexperimental/starlark-rust/

Not quite. Stable Diffusion is CLIP guided, but I wouldn't say it's "basically" how it works. It's one of the core

Also, just fyi, Google's alternative to Stable Diffusion/DALLE-2, Imagen is not CLIP guided. Thus being CLIP guided is not necessary for the problem.

In the slides for unsupervised learning, what is meant by "Maximum Entropy"? Doesn't this just imply that the distribution will be uniform; i.e. it's no better than making a blind guess?

this is the most interesting stream I've seen in a very long time!