Chabsff

I think you are confusing Black Holes with Hawking Radiation . The later's status is basically exactly as you describe.

Yeah, these are trivial optimizations.

I think you are misinterpreting. The distribution present in the training set in isolation (the one I'm referring to, and is not fuzzy in the slightest) is not the same thing as the distribution understood by the trained model (the one you are referring to, and is definitely more conceptual and hard to characterize in non-trivial cases).

"Generalization" is simply the theoretical measure of how much the later extends beyond the former, regardless of how that's achieved.

That's a common mechanism to achieve generalization, but the term is a little more general (heh) than that. It specifically refers to correctly handling data that lives outside the distribution presented by the training data.

It's a description of a behavior, not a mechanism. Which may or may not be appropriate depending on whether you are talking about *what* the model does or *how* it achieves it.

> There’s a reasonable argument for putting the top professors together in one school, sure, and maybe even PhD students.

Who's "putting" the professors there? The entire thing seemingly hinges on the idea that Harvard's role in society is somehow intentional and planned, as opposed to emergent and organic. I just don't buy it.

The institution's stated objective may be the creation "citizen-leaders", but the influence Harvard has, and the harm this causes, is entirely predicated on our willingness to buy that narrative.

Make an argument that Harvard's importance and credibility is vastly overrated, go ahead. I'm fully on board with that. But don't go blaming the institution itself for it. There's a ton of organizations with similarly lofty goals and aspirations, but we don't consider them harmful. That's because the harm is coming from without, not within.

Harvard doesn't need to not exist for us to be able to ignore it.

The issue with that is that "Gets to read and/or write the DOM" happens to be the only permissions a nefarious extension needs while also being those that a vast number of useful extensions require.

They do quite a bit more sampling in order to dynamically determine a good delta value. But apart from that, I dare say that I got it broadly right.

It feels to me like there's also quite a bit of temporal coherence that could be leveraged in order to accelerate the process.

If I had to guess: 1. Get partial derivatives of each parameter's influence on the moved object by sampling the function twice. 2. Perform a bog standard gradient descent. 3. go back to 1 until convergence is achieved.

Or you could be lazy and just throw an off-the-shelf optimizer at it.

The difference being that it's somewhat related to the app's operation. In this case, it's completely orthogonal to the app's marketed function.

If I'm reading this right, the caveat is that the exploit only lets you read registers that have been saved for context-switching.

So, in order to extract data, that data must be in constant active use (i.e. loaded in a register) at the time of the attack.

> Isn't "reasoning" a functional property though? If from the outside it performs all the functions of reasoning, it doesn't matter what is happening inside of the black box.

Yes, that's my point exactly.

I keep getting surprised at how a large chunk of HN's demographic seemingly struggles with the simple notion that a black box's interface informs surprisingly little about its content.

I'm not saying that GPT-4 is reasoning or not, just that discounting the possibility solely based on it interfacing to the world via a stochastic parrot makes no sense to me.

If you think of a model as a function approximator with an error that can only be characterized empirically, it's not a bad term at all to describe the class of algorithms ANNs belong to.

It's a real shame that the term is being abused so badly, because it's really appropriate in a lot of these cases. Or rather, it would be if people used it mindfully.

Superconductors also have an inherent current limit above which they go back to having a resistance.

But the performance binning is a direct result of careful design that goes out of its way to ensure that a subset of failures can still lead to a workable/binnable products.

It's still a failure to produce a part that matches the full design.

Since when is NPR a government-controlled platform?

The very next paragraph goes into specific details wrt/ how Celsius allegedly lied to their clients.

"The agency said Celsius engaged in "risky trading practices" and made uncollateralized loans, despite telling investors that it did not. The company also falsely claimed to have raised $50 million from selling its token, and claimed to have 1 million active users when in fact it had only around 500,000 depositors, many of whom were no longer active, the SEC said."

Securities or not, selling something while knowingly lying to buyers about what it is they are purchasing is fraud.

A pure one-way notification system is not a "twitter variant", but a completely different beast altogether.

The draw of the twitter-like approach is that the government messages are a portion of an existing stream of communication that people are already using/consuming.

A large social platform simply cannot survive without constant moderation that goes beyond strict application of the law. You need some form of community standards in place.

A government agency governing what is acceptable speech is a bad idea.

When you get down to real-time OSs, jitter often becomes the only metric that actually matters, and raw throughput becomes a means to that end.

On the flip side, languages like C,C++ and Rust have the major benefit of having next to no runtime component to it, allowing trace-driven fuzz testing to achieve a much higher level of confidence in its test coverage. For a tool like sudo, this can matter a lot.

Think of it more as: It's still possible, painful as it may sometimes be, to debug optimised C++ code running at full speed.

Kinda. But it`s going to be a lot like how data compression works. There will always be a somewhat fundamental limit to how much "creativity" you can get out of a small prompt generating large texts when using an isolated model.

"basically just massively parallel CPUs" is correct-ish, but it has the added wrinkle that you have to think of them as CPUs where large chunks of cores have to be executing the same instruction at the same time, which means that it's mostly loops where each iteration runs close to the same instructions that make sense.

Also, I think you might be drastically underestimating how utterly insane modern JavaScript engines like V8 are. JS code running as well as it does on CPUs is sort of a minor miracle in the first place. Even then, there's still a place/need for WebASM on top of it.

Transposing that unto a GPU in a transparent manner is asking a LOT. Not to mention that there's a lot of stuff you can do in JS that, if feasible at all, makes no sense whatsoever in GPU-land. Even basic stuff, e.g. string-based property lookups, just does not belong in GPU code for the most part.

If I see an API that looks like `GPU.exec(Callable)`, then I expect that any callable can be passed to that API. In JavaScript, that can mean a LOT of different things, many of which would be hell on earth to convert to GPU-compatible code.

Standard web APIs are a lot like kernel-level OS features. They have a ton of inertia to them, so they arguably should be limited to stuff that is infeasible in "userland". (There are additional reasons for that in the case of OSs, but that's the relevant one here).

If you had such a high-level API baked in, it would get leapfrogged by some library project within a few years, and then we'd be stuck with yet another API to support that no one actually uses.

TL;DR; It has to work blazingly fast on all kinds of GPUs, which are not nearly as homogeneous as you might expect. The complex setup is the "lowest common denominator" of that ecosystem.

GPUs are stupendously good at ridiculously wide parallel processing, yet you still need to sequence these operations. Modern Graphics API setups like Vulkan and WebGPU are the currently best known way to write such systems. Shaders express the parallel algorithms, and the pipelines binds and synchronizes them together.

It's just legitimately the best way, as far as we know, to get the most bang out of your buck for that hardware while remaining vendor-agnostic. Anyways, a higher-level abstraction can always be built on top that provides you with the UX you desire, and we will see a bunch of them for WebGPU soon enough.

No one here is disputing that.

The question is whether whomever builds them can make a profit doing so, or will they just end up being the suckers that everyone who actually makes money piggybacks off. It's really not clear at the moment.

Thanks for the clarification.

I don't have the background to be confident about this, but aren't the predicates on which Hawking Radiation is based on part of the equivalency framework between sonic and "real" black holes?

If so, then while the observation of Hawking radiation in the model is certainly interesting, calling it an observation of Hawking radiation with regards to real black holes sounds like a stretch.

Hawking radiation has been observed? When did that happen?

Why does it have to be a separate group?

What makes you think that the AI researchers who perform these breakthroughs can't possibly be the ones who are concerned with collateral damage and harm that the tech they are developing could cause?