Piezoid's comments

Not a word on Palantir. Is this because of the adept wording by the ministry of justice? I highly doubt they are developing this in a vacuum.

As re reminder, In the UK Palantir holds extensive contracts across defense (multi-billion MoD deals for AI-driven battlefield and intelligence systems) and healthcare (7y £330m+ NHS Data Platform). In France, its involvement is narrower but concentrated on *domestic* intelligence.

Close floating-point subtraction loses precision: when x >> 1, sqrt(x+1) ≈ sqrt(x), so their difference suffers cancellation and end up rounding to zero. In contrast, sqrt(x+1) + sqrt(x) approaches 2*sqrt(x) smoothly.

The interstimulus interval (ISI) for vision is much longer than most flicker rates or frame intervals in displays and projectors. However flicker can be perceived through temporal aliasing. For lighting, even simple motion in the scene can reveal flicker. Waving your spread fingers in front of your eyes is a sure way to detect flicker.

What you're describing is likely saccadic masking, where the brain suppresses visual input during eye movements. It "freezes" perception just before a saccade and masks the blur, extending the perception of a "frame" up to the point in time of the sharp onset of masking. That's how you get a still of a partially illuminated frame instead of the blended together colors.

I’m no expert in this, but if you're curious, check out the Wikipedia pages on interstimulus interval, saccadic masking, chronostasis, and related research.

Why not add a pressure relief valve on the quench path with a very loud whistle? That should be enough to take care of such rare and compounded failures.

What does recall means in this context? De-energizing the superconductor and shipping it back? Seems like a waste and a planning nightmare.

Speculation: retrieval diminished generation?

Implementations usually replace replace the 1 in the denominator with exp(-max(x)) for this reason.

There is a video by PBS Space Time on that subject: https://youtu.be/GcfLZSL7YGw

44 strn?cpy, 287 strlen; SQLite: 20 strn?cpy, 182 strlen in 1.4x C slocs.

One approach is to perform the bitstream parsing and Huffman decoding concurrently, while carrying out the LZ77 decoding sequentially. This method does not rely on a specialized encoder, such as pigz, that isolates LZ references into chunks.

In neuroscience, predictive coding [1] is a theory that proposes the brain makes predictions about incoming sensory information and adjusts them based on any discrepancies between the predicted and actual sensory input. It involves simultaneous learning and inference, and there is some research [2] that suggests it is related to back-propagation.

Given that large language models perform some kind of implicit gradient descent during in-context learning, it raises the question of whether they are also doing some form of predictive coding. If so, could this provide insights on how to better leverage stochasticity in language models?

I'm not particularly knowledgeable in the area of probabilistic (variational) inference, I realize that attempting to draw connections to this topic might be a bit of a stretch.

[1] The free-energy principle: a unified brain theory: <https://www.fil.ion.ucl.ac.uk/~karl/The%20free-energy%20prin...>

[2] Predictive Coding: Towards a Future of Deep Learning beyond Backpropagation?: https://arxiv.org/abs/2202.09467

It's been in the code base from the start: https://github.com/golang/go/blob/e8a02230/src/lib/net/net.g...

    We downloaded libgen sql and zlib sql and exported the necessary data from them.

Where does this "zlib sql" come from? Anna's pilimi-zlib2-index?

This make me wonder if flat-earth and other limiting cosmological views are mental shields against the realization that nothing matters except our peculiar existence.

I use the event loop to defer the (io heavy) post-processing of some requests without involving an off-process task runner like Celery. I use a custom implementation of this: https://django-simple-task.readthedocs.io/how-it-works.html It is way simpler when you don't need strong guaranties and checkpoints persistence.

Other works on reversible / permutation based / mixing hash functions : https://papa.bretmulvey.com/post/124027987928/hash-functions https://nullprogram.com/blog/2018/07/31/ https://gist.github.com/lh3/59882d6b96166dfc3d8d

Code reuse is achievable by (mis)using the preprocessor system. It is possible to build a somewhat usable API, even for intrusive data structures. (eg. the linux kernel and klib[1])

I do agree that generics are required for modern programming, but for some, the cost of complexity of modern languages (compared to C) and the importance of compatibility seem to outweigh the benefits.

[1]: http://attractivechaos.github.io/klib

I can think of many specialized applications where the versatility is superfluous while the size of the model prohibit inference on the edge.

Do you know if there is available methods for shrinking a fine-tuned derivative of such big models?

Beside generating a specialized corpora using the big model and then train a smaller model on it, is there a more direct way to reduce the matrices dimensions while optimizing for a more specific inference problem? How far can we scale down before the need of a different network topology?

Jaimie Mantzel: A guy in Panama building atypical low tech off grid solutions and small boats https://www.youtube.com/user/JMEMantzel

This add-on is using solvespace for solving constraints.

The is a python API for it's constraints solver: https://pyslvs-ui.readthedocs.io/en/stable/python-solvespace... However the solid geometry engine is tightly coupled with the application and not exposed by a public API.