atq2119

That really depends on which country you're in.

The solution is that the probes were built by a long ago technological civilization on Earth as a desperate measure in an interstellar war.

The probes are out there and were programmed never to come back to Earth.

You forgot about branch predictors.

'cough' could share a root with 'keuchen' (IANAL)

The operations could be short-circuiting.

Agreed. There is no sane reason why live translation and/or its privacy properties should depend on the specific headphones used. Even if the live translation were to happen in the headphones themselves, that should only tie the availability of the feature to the headphones. The privacy implications ought to be orthogonal.

I see three possibilities. Either the whole thing is made up entirely by Apple for bad faith reasons. Or some non-technical person with bad faith motivations at Apple suffered from some internal misunderstanding. Or somebody at Apple made some incredibly bad technical decisions.

Basically, there's no way that this isn't a screw up by somebody at Apple in some form. We just can't say which it is without additional information.

It's misleading to compare a desktop GPU against a data center GPU on these metrics. Blackwell data center tenor cores are different from Blackwell consumer tensor cores, and same for the AMD side.

Also, the size of the native / atomic matrix fragment size isn't relevant for memory bandwidth because you can always build larger matrices out of multiple fragments in the register file. A single matrix fragment is read from memory once and used in multiple matmul instructions, which has the same effect on memory bandwidth as using a single larger matmul instruction.

Affine transformations don't change relative density.

You can think of it this way. There's a density function on the shapes in question. Whenever you transform the 2d space, you have to adjust the density at the same time to preserve "volume" (area times density).

Non-linear transforms, such as interpreting a square as polar coordinates to obtain a disk, will expand or shrink area differently in different parts of the space, which means that if you start with a uniform density, you end up with a non-uniform density. But linear/affine transforms affect area the same everywhere in the space, and so if the density is uniform to begin with, it remains uniform.

I suspect at least in part it is to move loyal customers into larger and more expensive segments over time.

Let's say the first car you get is a Polo and you really like it, so your next one is a Polo as well. Over the decades, you're being moved to making more expensive car purchase.

And to make up for that, a new smaller cheaper tier is introduced at some point. I don't care about cars enough to know when they introduced the Up, but it certainly didn't exist a few decades ago.

Google aren't advertising their search as "for entertainment purposes only" though.

And even if they did, it wouldn't really matter. The way Google search is overwhelmingly used in practice, misinformation spread by it is a public hazard and needs to be treated as such.

Yes, they should also be held liable, but clearly the case of AI is worse.

In your hypothetical, Google is only copying a snippet from a website. They're only responsible for amplifying the reach of that snippet.

In the OP case, Google are editorializing, which means it is clearly Google's own speech doing the libel.

I think this is the right way to look at it. Privacy is extremely important to me, but cars are basically lethal weapons. Using them on public roads has to come with a certain amount of responsibility that balances privacy against other goods.

When using APIs, you pay for reasoning tokens like you do for actual outputs. So, the estimation on a per-token basis is not affected by reasoning.

What reasoning affects is the ratio of input to output tokens, and since input tokens are cheaper, that may well affect the economics in the end.

> Basically anything that requires a massively parallel computation on undeterminable states that are only clear in hindsight.

If only. This description makes it sound as if quantum computers could help efficiently solve all problems in NP, which is not believed to be true.

Those "undeterminable" states need some non-trivial algebraic structure so that destructive interference of states can do its magic in a quantum computer. Finding such a structure is incredibly difficult, if it exists at all.

The other thing is that whenever I see graphs like that spanning decades but not using a logarithmic scale, I can't help but roll my eyes a bit.

We may well be approaching a dotcom moment, but this kind of graph automatically exaggerates what's happening more recently.

By now I'd assume that all modern high performance CPUs use some form of TAGE (tagged geometric history) branch prediction, so that's a good keyword to search for if you really want to get into it.

What you're replying to is an analogy, that you seem to completely fail to understand.

The next step after pipe operators would be reverse assignment statements to capture the results.

I find myself increasingly frustrated at seeing code like 'let foo = many lines of code'. Let me write something like 'many lines of code =: foo'.

I'd say the main difference is that in traditional GPU languages, the thread of execution is a single lane of a warp or wave. You typically work with ~fp32-sized values, and those are mapped by the compiler to one lane of a 32-wide vector register in a wave (or 16- to 128-wide depending on the architecture). Control flow often has to be implemented through implicit masking as different threads mapped to lanes of the same vector can make different control flow decisions (that is, an if statement in the source program gets compiled to an instruction sequence that uses masking in some way - the details vary by vendor).

In tile languages, the thread of execution is an entire workgroup (or block in CUDA-speak). You typically work with large vector/matrix-sized values. The compiler decides how to distribute those values onto vector registers across waves of the workgroup. (Example: if your program has a value that is a 32x32 matrix of fp32 elements and a workgroup has 8 32-wide waves, the value will be implemented as 4 standard-sized vector registers in each wave of the workgroup.) All control flow affects the entire workgroup equally since the ToE is the entire workgroup, and so the compiler does not have to do implicit masking. Instead, tile languages usually have provisions for explicit masking using boolean vectors/matrices.

Tile languages are a new phenomenon and clearly disagree on what the exact level of abstraction should be. For example, Triton mostly hides the details of shared memory from the programmer and lets the compiler take care of software pipelined loads, while in this Tilus here, it looks like the programmer has to program shared memory use explicitly.

You obviously get errors in that case, which is not great.

But GP's point was that there is an entire other category of errors with git-lfs that are eliminated with this more native approach. Git-lfs allows you to get into an inconsistent state e.g. when you interrupt a git action that just doesn't happen with native git.

At least for desktop gaming, the tensor cores are in the GPU compute units (SM), same as for the big data center GPUs.

It seems ARM believe it makes sense to go a different route for mobile gaming.

The marketing speak isn't exactly clear, but I believe the point is that this is like an NPU inside of the GPU instead of next to it as a separate device. That would indeed be new, and I can see how it'd be beneficial to integration with games.

I'd say it depends. For the total parameter count, you should just count all parameters, since that's what matters for memory requirements.

For activated parameters: All unembedding parameters are used in every inference step during token generation, but only one column of the embeddings is used (if done right). So count accordingly, since that's what matters for memory bandwidth and therefore latency.

That effectively becomes a subsidy to those employers though, plus an incentive to drive wages down even more.

FWIW, and this depends on the language obviously, but formal memory models typically do forbid races between atomic and non-atomic accesses to the same memory location.

While what you were doing may have been fine given your context, if you're targeting e.g. standard C++, you really shouldn't be doing it (it's UB). You can usually get the same result with relaxed atomic load/store.

(As far as AI is concerned, I do agree that the model should just have followed your direction though.)

No, the issue in Linux is that userspace has traditionally had a tendency to break itself.

The overhead is certainly less.

I haven't felt the need to run a graphical application as a different user in a long time, but presumably you could forward the right environment variables and have it work including HW acceleration (which ssh X forwarding certainly doesn't support)

> localhost ssh connection to a second account

Any particular reason why you cannot simply use su or sudo for this?

This is a disingenuous response because I made it plenty clear what I meant with "fast": interactive response times.

And for that, we absolutely do have points of comparison, and yeah, pretty much all web apps have bad interactivity because they are limited too much by network round trip times. It's an absolute unicorn web app that does enough offline caching.

It's also absurd to assume that applications are as fast as they could be. There is basically always room for improvement, it's just not being prioritised. Which is the whole point here.

And yet we live in a world of (especially web) apps that are incredibly slow, in the sense that an update in response to user input might take multiple seconds.

Yes, fast wins people over. And yet we live in a world where the actual experience of every day computing is often slow as molasses.