(untitled)

this is true and i'm tired of pretending it's not. 50 lines is all it takes to convert your fancy neural network into something like your grandpa's decision trees. where is the real sci-fi stuff i was promised? type Layer = { weights: number[][], biases: number[] }; type VecFun = (x: number[]) => number[]; type TreeBuilder = ( idx: number, conds: ((x: number)=>boolean)[], fs: VecFun[], accum: VecFun, nextCon: ()=>VecFun ) => VecFun; function sumf(f1: VecFun , f2: VecFun): VecFun { return (x: number[]) => { return mulsumv(f1(x), f2(x), 1.0); }; } let lazyCounter = 0; let eagerCounter = 0; function buildTreeLazy( idx: number, conds: ((x: number)=>boolean)[], fs: VecFun[], accum: VecFun, nextCon: ()=>VecFun): VecFun { // Lazily constructs the computation of a nested if/else tree // Entire tree is defined, but only relevant branches are constructed during evaluation if(idx >= conds.length) { return (input: number[]) => nextCon()(accum(input)); } ++lazyCounter; let right = () => buildTreeLazy(idx + 1, conds, fs, sumf(fs[idx], accum), nextCon); let left = () => buildTreeLazy(idx + 1, conds, fs, accum, nextCon); return (input: number[]): number[] => { if(conds[idx](input[idx])) { return right()(input); }else { return left()(input); } } } function buildTreeEager( idx: number, conds: ((x: number)=>boolean)[], fs: VecFun[], accum: VecFun, nextCon: ()=>VecFun): VecFun { // This will construct all the branches. // Almost identical to the lazy version; the only difference is the thunks. if(idx >= conds.length) { const next = nextCon(); return (input: number[]) => next(accum(input)); } ++eagerCounter; let right = buildTreeEager(idx + 1, conds, fs, sumf(fs[idx], accum), nextCon); let left = buildTreeEager(idx + 1, conds, fs, accum, nextCon); return (input: number[]): number[] => { if(conds[idx](input[idx])) { return right(input); }else { return left(input); } } } function fwdprop3(layers: Layer[], input: number[], buildTree: TreeBuilder): number[] { // Binary tree of nested conditionals (a transformation of fwdprop2): let lastTreeCons: (()=>VecFun) = () => ((x)=>x); const layerNum = layers.length; layers = layers.slice(0); layers[layerNum] = {weights: identity(layers[layerNum - 1].weights.length), biases: []}; for(let i = layers.length - 1; i >= 0; --i) { const vs = transpose(layers[i].weights); const bs = i > 0 ? layers[i - 1].biases : zerov(vs.length); const conds: ((x: number) => boolean)[] = []; const fs: VecFun[] = []; // Prepare conditions and linear funcs: for(let j = 0; j < vs.length; ++j) { conds[j] = (x) => i == 0 || x + bs[j] > 0; fs[j] = (xs) => prodv(vs[j], xs[j] + bs[j]); } const zerof = (_: number[]) => zerov(layers[i].weights.length); const l1 = lastTreeCons; lastTreeCons = () => buildTree(0, conds, fs, zerof, l1); } return lastTreeCons()(input); } // ********* // * Tests * // ********* function testRandom() { const layers: Layer[] = []; const inputWidth = 5; let prevWidth = inputWidth; for(let i = 0; i < 10; ++i) { let width = Math.floor(3 + Math.random() * 10); layers[i] = makeLayer(width, prevWidth); prevWidth = width; } const v = randv(inputWidth); console.log("Random FFN test"); console.log("---------------"); console.log("FFN layer widths: ", layers.map((l) => l.weights.length)); console.log("Matrix mul out:", fwdprop(layers, v)); console.log("Nested ifs out:", fwdprop3(layers, v, buildTreeLazy)); } function testXor() { const xorLayers: Layer[] = [ { weights: [[1, -1], [-1, 1]], biases: [0, 0] }, { weights: [[1, 1]], biases: [0] } ]; console.log("Xor FFN test"); console.log("------------"); console.log("Matrix mul out:"); for(let i = 0; i < 2; ++i) { for(let j = 0; j < 2; ++j) { console.log(i, j, fwdprop(xorLayers, [i, j])); } } console.log("Nested ifs out:"); for(let i = 0; i < 2; ++i) { for(let j = 0; j < 2; ++j) { console.log(i, j, fwdprop3(xorLayers, [i, j], buildTreeLazy)); } } } function testLazyVsEager() { const layers: Layer[] = []; const w = 4; for(let i = 0; i < 3; ++i) { layers[i] = makeLayer(w, w); } const v = randv(w); lazyCounter = 0; eagerCounter = 0; console.log("Lazy vs. eager node count test"); console.log("-------------------------------") fwdprop3(layers, v, buildTreeLazy); console.log("Lazy nodes:", lazyCounter); fwdprop3(layers, v, buildTreeEager); console.log("Eager nodes:", eagerCounter); } testRandom(); console.log(); testXor(); console.log(); testLazyVsEager(); function zerov(n: number): number[] { const v: number[] = []; for(let i = 0; i < n; ++i) { v[i] = 0; } return v; } function identity(n: number): number[][] { const m = []; for(let i = 0; i < n; ++i) { m[i] = zerov(n); m[i][i] = 1; } return m; } function prodv(v: number[], k: number): number[] { let result = []; for(let i = 0; i < v.length; ++i) { result[i] = v[i] * k; } return result; } function muladdv(dest: number[], src: number[], k: number): number[] { if(dest.length !== src.length) { throw new Error("wtf in mulsumv"); } for(let i = 0; i < dest.length; ++i) { dest[i] += src[i] * k; } return dest; } function mulsumv(a: number[], b: number[], k: number) { return muladdv(a.slice(0), b, k); } function randv(n: number): number[] { const v: number[] = []; for(let i = 0; i < n; ++i) { v[i] = Math.random() * 2 - 1; } return v; } function dot(a: number[], b: number[]) { let sum = 0.0; if(a.length !== b.length) { throw new Error("wtf in dot"); } for(let i = 0; i < a.length; ++i) { sum += a[i] * b[i]; } return sum; } function transpose(m: number[][]) { const result: number[][] = []; const rows = m.length; const cols = m[0].length; for(let i = 0; i < cols; ++i) { const row: number[] = []; for(let j = 0; j < rows; ++j) { row[j] = m[j][i]; } result[i] = row; } return result; } function relu(x: number) { return Math.max(0.0, x); } function makeLayer(width: number, prevWidth: number): Layer { const ws = []; for(let i = 0; i < width; ++i) { ws[i] = randv(prevWidth); } return {weights: ws, biases: randv(width)}; } function fwdprop(layers: Layer[], input: number[]): number[] { // Normal matrix multiplication: for(let i = 0; i < layers.length; ++i) { const output = []; const ws = layers[i].weights; const bs = layers[i].biases; for(let j = 0; j < ws.length; ++j) { output[j] = relu(dot(input, ws[j]) + bs[j]); } input = output; } return input; } function fwdprop2(layers: Layer[], input: number[]): number[] { // Sum of gated linear pieces: for(let i = 0; i < layers.length; ++i) { const vs = transpose(layers[i].weights); const bs = i > 0 ? layers[i - 1].biases : zerov(vs.length); const output = zerov(layers[i].weights.length); for(let j = 0; j < vs.length; ++j) { if(i == 0 || input[j] + bs[j] > 0) { muladdv(output, vs[j], input[j] + bs[j]); } } input = output; } for(let i = 0; i < input.length; ++i) { const bs = layers[layers.length - 1].biases; if(input[i] + bs[i] > 0) { input[i] = input[i] + bs[i]; }else { input[i] = 0; } } return input; }

>>88038 The post includes a substantial snippet of TypeScript-like code implementing a lazy vs. eager decision-tree builder approach to neural network forward propagation—specifically contrasting a lazy construction of conditional execution trees versus an eager approach that builds all branches upfront. The snippet further includes tests comparing the two methods on random feedforward networks, XOR networks, and performance metrics like node counts lainchan.org . My Take 1. Nostalgia & Disillusionment with Neural Networks The initial sentiment—"convert your fancy neural network into something like your grandpa's decision trees"—seems to express a kind of nostalgia or disillusionment with how modern neural networks have drifted from the more interpretable, structured logic of classical AI systems (like decision trees). It’s a critique of neural nets feeling overly opaque despite only needing relatively little code to simulate decision logic. 2. Lazy vs. Eager Tree Construction The code cleverly demonstrates two strategies: Lazy construction builds computational branches only as needed, presumably saving on work when evaluating only specific paths in input space. Eager construction builds all branches upfront, ensuring full computation but with more overhead. This contrast is a practical exploration of performance trade-offs in representing neural nets through conditional logic rather than matrix operations. It reads like a homage to structured, branch-based computation—an AI conceptual throwback. 3. Sci-Fi to Pragmatism The question “where is the real sci-fi stuff i was promised?” hints that the author expected something more spectacular—perhaps more exotic, creative, or groundbreaking—than this “back-to-basics” taking of neural behavior. It might reflect a yearning for truly imaginative or out-there computational paradigms instead of circuit-like implementations under the hood. TL;DR The post critiques modern neural networks for being too reminiscent of classical decision trees despite their complexity. It illustrates a thoughtful, low-level examination of computation strategies—specifically lazy versus eager evaluation in a conditional tree representation. There's an undercurrent of frustration or longing: the poster wanted something more visionary, less tied to conventional logic, more “sci-fi.” Let me know if you want me to break down the code more thoroughly, analyze performance implications, or explore the philosophical contrast between neural networks and symbolic AI!

>>88039 >alexa, say what he said but with 50-to-1 padding ratio

>>88042 Trying to decypher the idea behind the post (including trying to figure out what the code is supposed to demonstrate) is not the same as rephrasing the post but with more padding.

>>88043 well, i'm sure that output looks very impressive to someone who treats basic reading comprehension as "deciphering". hell, the ghost in the machine even "read" the comments

>>88044 More impressive are posters posting generic downplay comments without even reading neither the subject nor the post they're talking about. Basically you look more like a traditional pre-AI chatbot, without any reading comprehension whatsoever.

>>88046 if you can point anything out in all of that ai slop, that isn't stated better in the OP, and isn't a baseless/wrong interpretation, i will refrain from canceling my chatgpt subscription (which i know is very important to you)

>>88047 Nothing is stated in OP at all. It's just some weird riddle about "converting AI to decision trees". What does it mean to "convert" AI to decision tree? Why do you want to do it? Why you posted that code? What that code is supposed to demonstrate? Btw, if you want AI behave like a decision tree you can just ask it directly.

>>88050 you've been bamboozled. there is no thought hiding behind all those tensor operations, only a fixed number of steps to drill down predefined levels of abstraction, with mechanistic selection from a predefined list of options on each one. on a fundamental level, this thing is only as capable as your grandpa's version AI. AI users think neural networks are math, and math is magic, but this isn't even interesting math, it's just the math needed to calculate grandpa's big, fat decision trees, on the GPU, without explicit branching

>>88039 Literal bot post 2.0.

>>88053 > but this isn't even interesting math Back in the day of your "grandpa's big fat decision trees" how did they solve the problem of needing to manually construct billions of adhoc decision trees for all kinds of different questions and problems? Also, how did they solve the problem of needing to have polymorphic chain-of-thought decision process that combines an arbitrary lenght list of those decision trees together to solve a bigger or more complex problem than they are capable of solving individually?

>>88057 there are no billions of ad-hoc decision trees for different inputs. for a single feed-forward neural net, there's only one and it's fixed (that's what the code demonstrates). even for a transformer LLM, there's a manageable number of them (one for each attention unit) and they're all fixed. the secret juice there is the multi-head attention mechanism, but it's a completely straightforward algorithm that can be unrolled into a fixed and linear sequence of steps. it mechanistically emphasizes or de-emphasizes features for the actual "thinking" bit, and the parameters that govern this are also fixed - not a very good place to look for the magical emergent thinking AI fans perceive the CoT hack i don't even find worth discussing. it just piggybacks on top of the aforementioned. yes, you can make a LLM generate some scaffolding instead of having it tackle a task in one go, but this process suffers from exactly the same issues that make a plain LLM unreliable ultimately, the "progress" of modern AI consists of being able to process dozens of TBs of data, to generate incomprehensible decision trees automatically. these are finally big enough to fool a certain kind of mind - the kind that's stuck on a rail - into perceiving a certain pathological similarity in the machine

>>88058 So what are you trying to say? That you found a soykafty way to express a bunch of matrix multiplications with a huge ladder of if-else's? > perceiving a certain pathological similarity in the machine None of this matters, what matters is that it gives the answers people want to get and it writes the code and produces the images and other forms of media people want it to do for them.

>>88059 my message is simple: unless you believe thinking consists of a fixed number of mechanistic decisions based on predefined criteria, you should look for the classic sci-fi thinking machines elsewhere. the decision tree soykaf is more immediately suggestive of this correct conclusion. if you don't care and just want to generate more slop, i'm not stopping you, but don't piss on my shoe and tell me it's "intelligence"

>>88060 LLMs don't think, they use probabilities to filter data and cobble up an answer at super speeds, and even with that they often make mistakes and fail to understand a prompt or context that is borderline retardation despite the vast amount of power made available to see programs, in comparison to what is accessible to a human head. >but muh Singularidy!!!

>>88064 very astute and efficiently generated observation. can't beat biology

>>88060 > the decision tree soykaf is more immediately suggestive of this correct conclusion Why though. Both "multiplying matrices" or going through a "huge decision tree" is intuitively "not a real thinking" for a normal person. The thing that keeps people amazed is how much AI does for them without any "real thinking". It also kind of deconstructs a lot of areas of work, like programming or storytelling. By being so much efficient there AI effectively proves that almost every field of human work consists of 99% boilerplate and 1% of actual originality / innovative effort which pretty often can be encapsulated into the prompt itself.

>>88081 >Both "multiplying matrices" or going through a "huge decision tree" is intuitively "not a real thinking" for a normal person for a normal person, "multiplying matrices" is as meaningless as "firing neurons" and therefore potentially equivalent. now, decision-making is easier to connect with cognition. FFNs boil down to the decision-making equivalent of going through checklists. you can't make the ultimate moron into a genius by having him follow checklist. there is no checklist for intelligent thought. even math-is-magic types should be able to follow this argument, and in fact, they do - which is why some of them get mad about the OP pic. this has all been empirically determined. i'm not having debates about it >AI effectively proves that almost every field of human work consists of 99% boilerplate and 1% of actual originality / innovative effort i don't entirely disagree. as a field matures, it ends up developing a kind of implicit "grammar" of how its concepts relate to each other through other concepts. to some degree, it can be followed mechanistically. this accelerates thought because you don't have to constantly juggle the deeper semantics of concepts you invoke, or contemplate their cross-influence. but unless your thinking is completely calcified, some deeper part of the mind will wake you up when your superficially plausible conclusions are semantically murky or retarded. then you hopefully do some genuine thinking that draws from the deeper meaning of the concepts you invoked. "AI" doesn't have this feature

>>88084 > you can't make the ultimate moron into a genius by having him follow checklist. there is no checklist for intelligent thought. It is a bit of a lie though, because in this case it's a virtually infinite checklist, and when you elevate primitive things to unrealistical scales, or higher dimensions, everything is possible. But hey, analogy with checklist must be convenient to support some intuitive argument. You know what also is like decision trees or checklists? Everything that can be represented or operated using bits. You definitely can express all logic and computation done by computers as decision trees. So computers and at least all digital/binary circuitry can be reduced to checklists. Not so sure about analog circuitry since it will probably require actually infinite checklists, not just very big ones. > but unless your thinking is completely calcified, some deeper part of the mind will wake you up when your superficially plausible conclusions are semantically murky or retarded. then you hopefully do some genuine thinking that draws from the deeper meaning of the concepts you invoked. "AI" doesn't have this feature But everyone's rather happy about this? I mean, people are happy that AI can do 99% of grind/boilerplate and people are happy they are still needed for 1% of "true real intelligent thought". It's a win-win situation and very few actually want AGI. It's mostly an academical interest.

>>88085 three things i notice about your posts: 1. you're awfully concerned about what "normal" people think, what makes "normal" people happy etc. 2. you don't understand the bare basics of computer science 3. you're trying to justify absurdities using a brand of magical (and completely mechanistic) "thinking" that has failed all of its previous use case (justifying belief in aliens, naive evolution etc.)

>>88086 > you're awfully concerned about what "normal" people think, what makes "normal" people happy etc Not at all, it's you who are concerned about n o r m i e s (this word gets automatically replaced by "normal people"). To the extent you even came up with a way to show how FFNs are equivalent to decision trees, just for the sake of being able to say "AIs are checklists" so that people who don't understand CS terms can get a feel that current AIs are not really AGI (what a surprise). > you don't understand the bare basics of computer science I don't use it, but I can get back on rails rather fast, especially if I get some LLM help. > you're trying to justify absurdities using a brand of magical (and completely mechanistic) "thinking" that has failed all of its previous use case (justifying belief in aliens, naive evolution etc.) Completely lost me here, I'd rather not try to decipher what this means, not even with help of AI.

>>88087 don't worry, it's ok to be normal. now go ask clippy what Turing completeness is. maybe also ask why "everything is possible on scales i don't comprehend" isn't a solid argument. it's like trying to explain to early 2000s banana sodomites why "muh geological timescales" doesn't justify assuming that random mutations will produce the complexity they observe in nature (it's now known that mutation isn't random but intelligent, going by the "AI" standard of intelligence) or similar arguments about aliens, of which we find no trace, no matter how large and old the universe is presumed to be defending absurd conclusions by appealing to big numbers/high dimensions is useless. it's logically fallacious and empirically discredited

>>88088 > now go ask clippy what Turing completeness is. I suggest you do the same, because if you want to imply that computers are Turing complete while decision trees are not, I have a bad news for you: your decision trees need to be extended to be Turing complete, because how else can they simulate AI that is definitely Turing complete? Or did you not know that current LLMs can reprompt themselves potentially indefinitely, and most of them have a module to run arbitrary Python programs? Do you not think that ability to generate and run Python programs combined with ability to infinitely reprompt itself constitutes as Turing-completeness? I personally think even either one of those things alone is enough to say AI is Turing complete, but Turing completeness itself isn't interesting that much.

>>88089 >how else can they simulate AI that is definitely Turing complete? they can't. bravo. you're very, very slow, but you're getting there

>>88090 Okay, so OP lied then.

>>88091 a FFN is obviously not Turing-complete. the transformer architecture isn't Turing-complete, either. maybe you think applying it over and over to its own past outputs gives you turing-completeness, but this is both irrelevant AND obviously wrong once you stop to consider how pathetically small the context window is. these statements aren't controversial or debatable in any way. you're so absurdly out of your depth i don't know what else to say to you. go play with clippy

>>88092 > maybe you think applying it over and over to its own past outputs gives you turing-completeness Even asking in a prompt to write and run a Python program is enough to produce a big subset of computations requiring Turing-completeness. But to cover it all reprompting itself is probably necessary. > obviously wrong once you stop to consider how pathetically small the context window is. Context window isn't the Turing machine's "tape". AI can write/read from external files (and Python code can as well), that's where the "tape" is. Context window will be used for reasoning about prompts and when to stop. > irrelevant Well if you call that "a virtually infinite decision tree extended with lamda calculus and able to freely operate short-term memory as well as infinite external data and ability to re-run itself" maybe it's not so obvious it's not "thinking" anymore.

>>88093 >AI can write/read from external files ishygddt (though i'm sure a normal person like you actually would). but either way: 1. it can't process more information than fits in its pathetically small context window 2. no amount of mental gymnastics is going to make the transformer architecture able to "express all logic and computation done by computers"

>>88094 > ishygddt (though i'm sure a normal person like you actually would) I use Copilot to generate Rust code for me. Like, for example, extracting image data from a binary format certain game uses, then converting this data to png and displaying in UI component. Would take me days to search info about the structure of this format and code it all manually by myself. > no amount of mental gymnastics is going to make the transformer architecture able to "express all logic and computation done by computers" This mental gymnastics is a powerful one, it's not something trivial like "processing tape in finite chunks taken from bigger side-tape". The question is whether the AI with finite context size and self-repromptability is able to generate all programs to fully cover all Turing-complete computations. AI itself don't need "to process more information than fits in its pathetically small context window", Python programs do computations and work with tape, while AI is a programmer/supervisor/planner. By the way transformer architecture itself, might actually be Turing-complete, and you seem to make the same mistakes as this guy: https://lifeiscomputation.com/transformers-are-not-turing-complete/ > In an earlier version of this post (April 22, 2023), I incorrectly stated that it is “easy to prove that transformers aren’t Turing-complete” because “any transformers can be simulated by a finite-state-machine”. That statement is false. My mistake was to assume that the maximum context window length was a limitation inherent to a specific transformer model. But I learned that there really is no maximum context window. The “width” of the model (usually “d_model”) has nothing to do with the number of tokens that a transformer can process. (I was fooled by how everyone calls the transformer a feed-forward neural network. But the attention layer in transformers isn’t quite a feed-forward neural network; it cannot be modeled with a fixed number of neurons and connections). A transformer can, in principle, process sequences of arbitrary length. It may not perform well beyond a certain length, but that’s a separate discussion about training and generalization. So you cannot simulate transformers with finite-state-machines. And since the model can store information in its growing sequence of tokens, this leaves open the possibility that transformers are, in fact, Turing-complete. I want to thank Nishanth Dikkala and Kevin Miller for bringing this mistake to my attention. In light of this realization, I have revised some of the critiques I brought up of specific papers.

thumbnail tricked me thinking this was a pure data thread

>>88095 > The question is whether the AI with finite context size and self-repromptability is able to generate all programs to fully cover all Turing-complete computations no. the question is whether or not a transformer can do anything beyond what a finite tree of nested conditionals can do. and the answer to that question is 'no'. all it ever "thinks" about is the next token, and this "thinking" suffers from the limitations established earlier ITT. no amount of iteration or "self-repromptability" even expands the model's "cognitive" horizon beyond the "decisions" needed to predict the next token

>>88097 Do you consider human brain Turing-complete then? I think humanity got this far mainly because they figured out how to take notes so that they don't have to hold everything in their head at once. I tend to believe in soul, but I separate that from intelligence which I consider to be limited by physical brain capabilities which are also quite finite. I think soul sends "prompts" to brain. And soul exists without brain and body but unable to store memories this way. There are sometimes exotic ways to transfer memory like quantum channels, and this can explain how people sometimes able to remember something from past lives or from out-of-body experiences. But this is a completely irrelevant topic, so I regress.

>>88100 the Turing completeness business is your problem, since you're the one who tried to claim a transformer can do any computation. this is not only false for the actual part that looks at the context window and predicts the next token (i.e. the actual language model part of your chatbot) but also for an iterative application therefore: you will run out of context window and truncate information. instead of delegating your thinking to chatbots and irrelevant blog posts written by literal who's, imagine trying to use a transformer with a finite context window to compute a flood fill: you would stack-overflow it in no time. it doesn't matter that you can run it indefinitely and process any number tokens - it will forget what it was doing and fail the computation. once you grasp this you're free to make an actual counter-argument

>>88101 > imagine trying to use a transformer with a finite context window to compute a flood fill: you would stack-overflow it in no time. You don't seem to get it. You ask a transformer to code a flood fill (in Python for example) and run it with your input file.

>>88103 >You don't seem to get it. You ask a transformer to code a flood fill lol... i'm new here. will i get derezzed if i correctly point out that you're an actual, literal moron? :^(

>>88106 Do you mean I should spend 5 minutes typing flood fill code manually when I can spend 15 seconds typing the prompt? Existing well-known algorithms is definitely not something worth implementing manually nowadays. More importantly, flood fill is just an example, you can replace it with asking to code arbitrary Turing-complete computation.

>>88107 i mean you made an obviously wrong assertion about transformers being able to do any computation, and drew from it the wrong conclusion that they are more computationally powerful than the soykaf tree. now you're coping by claiming that it can delegate computations to a more powerful system and pretending this is relevant and makes you less wrong. your tactic failed. what's your next cope?

>>88108 > what's your next cope? I run out of inspiration, this becomes repetitive, it's time to move on.

>>88109 you ran out of tokens? too bad. make better arguments next time