what if it's something correct that doesn't have a counterargument, like "photons with a 450nm wavelength are perceived as red by the average human eye"

And how would it know if a counterargument exists anyway, and if it actually does make sense?

deterministic is useless if it means it will always make the same mistake it did the first time.

but some tokens are only not allowed in certain contexts, not others.

You might be talking about how to defuse a bomb, instead of building one. Or you might be talking about a bomb in a video game. Or you could be talking about someone being "da bomb!". Or maybe the history of certain types of bombs. Or a ton of other possible contexts. You can't just block the "bomb" token. Or the word explosive when followed by "device", or "rapid unscheduled disassembly contraption". You just can't predict all infinite wrong possibilities.

And there is no way to figure out which contexts the word is safe in.

I'm responding to:

> Fundamentally there's no way to deterministically guarantee anything about the output.

with the fact that you can e.g. force a network to output e.g. syntactically correct code, as long as you can syntax check each token.

You just said an oxymoron right there.

If you're syntax checking every token, you're doing it AFTER the llm has spat out its output. You didn't actually do anything to force the llm to produce correct code. You just reject invalid output after the fact.

If you could force it to emit syntactically correct code, you wouldn't need to perform a separate manual syntax check afterwards.

No, you disallow the LLM to generate invalid tokens. That means you "force it to emit syntactically correct code"

how do you disallow it from generating specific things? My point is that you can't. And again, how do you stop it generating certain tokens, but only in certain contexts?

E.g. you ask it what's 2+2, and only allow it to generate digits in the response. Set other probabilities to 0, then sample the rest. This is trivial.

but it doesn't have that much more flops than it did a couple of years ago.

From my research you can always fit it in a 32x32 multiply, you only need the extra bit at compile time. The extra bit tells you how to adjust the result in the end, but the adjustment is also a constant.

they should do both.

A Boeing 777 burns 300g of fuel per second per engine, while taxiing on the ground... so 2 gallons gets you somewhere between 10 and 15 seconds of taxiing.

The first argument really really does not make sense.

You can also increase economies of scale by building out solar farms, and using them for something useful, instead of wasting it on guessing random hashes.

Saying that wasting energy is fine as long as you get it cleanly doesn't change the fact that you're still wasting it.

no mention of thomas edison not inventing the lightbulb?

so if these "guardrails" really do work (which they don't), why wouldn't you just use them up front?