nighthawk454

Wow this looks really great! Looks very cheap and accessible. Is there any minimum material thickness, beyond the height of the board plus magnets?

I’m also curious - can the modeling estimate the deformation of the eFlesh or does it just detect a 2d ‘pressure’ field? Not sure why it would be needed, but

Also, do custom geometries require training a new network?

Thanks!

Frankly, you’re ignoring the definition at this point. A “good hash algo” only generates noise in the cryptographic hash sense. There are in fact other hashes. The fact that “semantic vectors” preserve a useful similarity is no different mathematically then LSH or many others (except that the models work a lot more usefully).

If you’re trying to say MD5 isn’t an LLM, then fine no argument there. But otherwise consider referencing something other than vibes or magic, because the definition is clear. “Semantic vectors” isn’t some keyword to be invoked that just generates entropy from the void.

No, mapping to a _fixed length code_, that’s it. Note that the output domain need not be smaller than the input domain either.

If your model takes a sequence of 1 or 10,000 or N tokens and returns a vector of fixed length, say 1500 dimensions, then it is a hash function of sorts.

> A hash function is any function that can be used to map data of arbitrary size to fixed-size values

https://en.m.wikipedia.org/wiki/Hash_function

I guess it depends on how loosely we take the definition. Wikipedia has it as just a function that maps variable length sequences to fixed length sequences. So by that definition most embedding networks fit.

Hashes are often assumed to be 1d, discrete valued, deterministic, uniformly distributed, and hard-to-reverse. And embeddings are often assumed to have semantic structure. Those two things certainly have some pretty different properties.

In the strict definitions, I’d say if hashing is just mapping to a fixed-size output space and an embedding is a projection/mapping of one space onto another (usually smaller) space, then they’re similar.

Some hash algorithms like SimHash or LSH use random projection onto sets of random hyperplanes to produce output vectors. Blurring the lines fairly well. You could even implement that as a NN with a single projection layer. Or indeed the torch.nn.Embedding class. Of course the outputs are usually then quantized or even binarized, but that’s more a use-case specific performance optimization not fundamental (and sometimes so are embeddings).

A hash function in general is only a function that maps input to a fixed-length output. So embeddings are hash functions.

You’re probably thinking of cryptographic hashes, where avoiding collisions is important. But it’s not intrinsic. For example, Locality Sensitive Hashing where specific types of collisions are encouraged.

I certainly agree, I think the financial mechanisms are not very obvious. Presumably somewhat by design. And yet it also seems to be one of the main tricks in modern financial engineering - it just keeps turning up. See also: corporate buybacks, private equity, private credit, mortgage backed securities, etc.

All are versions of this ‘shuffling of risk’ from debtors to “investors”. The middlemen take their cut along the way. Then if and when the bubble bursts debtors default and investors take a bath. Or the slow case, the debt inflates away and investors pay for it in lack of returns, ultimately losing money in real terms despite balances going up.

While BNPL by itself may not be large enough to do the economy in, some of those other examples mentioned are. And I imagine there’s probably some joint risk from running so many instances of this scheme at once (i.e. one goes out they all go out).

This is blatantly just increasing debt load. What does a business do if they need forever growth, but can’t increase their prices further without losing net revenue? Raise prices anyway and push people to finance it.

This is broadly not good for people. Financing things like your food or your rent (seriously - that’s a thing here) doesn’t help if they’re recurring. It’s not like people are gonna need to just finance one month’s rent payment and then they’re solvent and paying off the next 4 months normally plus installments. Really, what could structurally change in someone’s personal finances over a 6-8 week term? If you couldn’t afford a burrito or rent this week, what possible belief is there that next month you can afford that plus debt service.

The loans are just gonna stack and stack. Which will drive people into more debt, and more need for continued financing. This isn’t a multi billion dollar business because people just need a temporary boost once every year or two because their paycheck timing is off. It’s a flywheel money extraction machine.

Securitizing these debts doesn’t make them a good idea for the consumers. It makes it good for the industry so it can scale it up larger. Which means more people in more debt more of the time with “investors” extracting wealth from it.

Plus then there’s the whole systemic risk of people not paying back. They bake into the rates some percentage of defaults, and the larger the pool size the safer that gets. This systemically is a bet that no more than X% of loans will default at once. Basically shorting loan defaults.

Which is cute and all until any economic situation hits where a bunch more people suddenly can’t pay at the same time. In which case the whole thing unwinds brutally. And given that the play is to literally sell financial products that increase pressure on people’s ability to pay… this is probably super unwise. Combine that with any of the major structural economic issues we have ongoing and you’re poking a sleeping pressure cooker.

The only real questions are how much can be extracted before it explodes, and who is the ultimate bag holder at the end?

“If you thought 2008 was fun, well hold my beer…” - finance, probably

By the looks of things, uv is telling you it’s creating a venv with Python 3.10.9 still. Since you didn’t specify you wanted another version, it probably defaulted to the first available system version.

What you want is `uv venv —python 3.11` to create a virtual environment with Python 3.11 without messing up your global system env. This should also install a portable version of Python 3.11 if needed (which it will be since you don’t have it).

https://docs.astral.sh/uv/pip/environments/#creating-a-virtu...

Interesting… from the intro the argument is that the Consumer Product Safety Commission ‘requested’ Amazon to issue recalls for products of third-party sellers due to safety hazards. Amazon complied “voluntarily”. Then CPSC wanted to treat Amazon as a distributor for third party products that are FBA (fulfilled by Amazon, using their logistics, warehousing, and distribution). Which Amazon takes issue with because third parties have the choice to opt out of that (?). Something something ‘just a marketplace’

Gotcha, thanks for the reply. Makes sense to target burstables first - that seems to be the most common feature set. That’s interesting that it’s not readily available in the kernel. I once spoke to some AWS folks dealing with Batch/ECS scheduling of docker container tasks and they hit similar limitations. As a result their CPU max/burst settings work like the underlying cgroups too.

I imagine writing a custom scheduler would be quite an undertaking!

Great article, thanks! I’ve been curious if there’s any scheduling optimizations for workloads that are extremely burst-y. Such as super low traffic websites or cron job type work - where you may want your database ‘provisioned’ all the time, but realistically it won’t get anywhere near even the 50% cpu minimum at any kind of sustained rate. Presumably those could be hosted at even a fraction of the burst cost. Is that a use case Ubicloud has considered?

Got it - thanks! I might suggest adding a comparison section to the website (whenever appropriate). Appreciate the response, I look forward to checking it out.

It’s an option for payment. Detailed on the same link:

> Storj created the STORJ utility token as a medium of exchange on its decentralized cloud storage network. The STORJ utility token facilitates payments from people around the world for their use of the Storj network to store their data, and Storj uses it to pay our community of Storage Node Operators that rent their unused hard drive capacity and bandwidth to the network.

Does anyone know how this compares to ErsatzTV?

Circuit breakers are now more common. The US has them at whole-market level and individual stock level. Somewhat like an API rate limit, there are tiered penalties - the bigger the intraday drop the longer the time-out period. In the worst case the market will be shut down for the day to cool off. This is one reason you occasionally hear about the exchange ‘stopping trading’ of a security.

More details here: https://www.investor.gov/introduction-investing/investing-ba...

Hey, nice project. It was genuinely refreshing to just mess with some sliders on something interactive and no-bullshit. Cheers!

Discussed here: https://news.ycombinator.com/item?id=43489136

This was a great YouTube video on the subject: https://www.youtube.com/watch?v=a-767WnbaCQ

A submission to 3blue1brown's SoME (summer of math explanation) competition

Some things don’t require scratch build, some do, some are in between. But there’s no prompt for taste.

Only if you’re describing orientation as two orthogonal rotations. I’m saying think of it like a ‘pointing’ vector that defines the axis of rotation. And such a vector does require 3 components in 3d space

If you click through to the interactive example, you can try it! You'll see that the if the above equations are `q`, then full formula to rotate a vector `v` is `v' = q * v * q^-1`

The easiest way for me to conceptualize it is to think of it as orientation + rotation. 3 dims for the orientation vector to get the object facing/pointing the right way, then a further 1 dim/var for rotation about that axis. For a total of 4 variables/dimensions

3blue1brown and Ben Eater did a series of interactive videos on the subject that can be explored:

https://eater.net/quaternions

My favorite demo on this point is this one: https://eater.net/quaternions/video/rotation

Where they have a toggle to go between `a + bi + cj + dk` quaternion notation and an equivalent formulation in terms of 3d orientation vector plus rotation angle as `cos(θ) + sin(θ)*(ai + bj + ck)`

Testing this out locally, repro'd pretty similar numbers on macOS ARM and docker. Unfortunately the CPU-only build isn't really any smaller either, thought it was

One ponders the connections with the Recall feature

Seems to be hugged, so here's a cached view

https://archive.is/w8yFG

https://web.archive.org/web/20250202094451/https://adriacabe... (images are cached better here)

Nice! Yeah that workflow feels pretty relatable. My other rule of thumb is if it's an architecture paper (system or neural net) without a diagram, I immediately bail haha

A nice trick for most papers is to skip the middle (at first). Just don’t read most of the lines of math. Focus on the inputs and outputs.

If the premise and conclusion don’t make sense on fundamentals the math isn’t likely to fix it. Most lines are literally equals signs - just walking you through some equivalencies as proof. A large statement saying “If ABC, then … (and then … and then … and then …) and finally XYZ”

The middle ‘and then’s aren’t really that important if the conclusion XYZ isn’t interesting. Or much more commonly, the ABC premise is false anyway so who cares.

Most readers I’d wager are not sitting here deciphering opaque gradient derivations every single paper. Just skip it unless it proves worthy

> eBPF is a technology that can run programs in a privileged context such as the operating system kernel. It is the successor to the Berkeley Packet Filter (BPF, with the "e" originally meaning "extended") filtering mechanism in Linux and is also used in non-networking parts of the Linux kernel as well.

> It is used to safely and efficiently extend the capabilities of the kernel at runtime without requiring changes to kernel source code or loading kernel modules. Safety is provided through an in-kernel verifier which performs static code analysis and rejects programs which crash, hang or otherwise interfere with the kernel negatively.

https://en.wikipedia.org/wiki/EBPF?useskin=vector

To run without setup:

uv run --python 3.13 --no-project --with bagels bagels

Sorry, you’re right, it pools again to a single comparison scalar in the end