This is, in fancy language and snowed under by enumeration of historical research, math and science, an argument that "computers can never have a soul".
From the article:
""" No matter how sophisticated the computation is ... there remains an unbridgeable gap (a “humanity gap”) between the ... ability of machine and the general problem solving ability of man. """
This is just standard dualist nonsense under the guise of logical objectivity.
Note that there is a deeper issue about the shortcomings of statistical pattern matching to do logic, which is what the paper I reference above is trying to get at, but the parent article's fundamental assumption/conclusion is that computers will never be able to reason.
1) stating human brains are actually hypercomputers, which cannot be implemented in real life at the moment
2) stating just what you said before: pattern matching, no matter how many layers or parameters used, is not all there is to intelligence/consciousness
At the moment, whether you like it or not, there's no proof at all the human brain works in any way like a Turing machine. That idea which has nothing to back it up is the usual POV here on HN and it is the actual faith-based belief but again, no scientific papers to back it up.
Extraordinary claims require extraordinary evidence, and absence of evidence is not evidence of absence.
Also, you wouldn't be able to simulate a specific existing brain due to the quantum no-cloning theorem.
To your point 2, this directly contradicts your point 1, and is, what I would call, a "dualist" philosophy. This is a basic statement that thinking, the way we do it, is fundamentally not mechanical and therefore not describable by our laws of physics. That is, however we think is literally not of this universe. The "dualism" comes in by naming the other "plane of existence" (or whatever you want to call it) as the companion universe or reality to ours where our intelligence effectively resides.
I think Turing is a little maligned here. His test was meant to strip away all the red herrings that one might use and focus on what (I'm imagining) he thought was the most fundamental of all human traits, the ability to reason and to use language. The Turing test is a functional one. If something talks like a human, reasons like a human, acts like a human, then how would you tell the difference between the "real" human and the "simulated" human? By creating a functional test, it gets at the core of the issue. If you can't come up with a test to differentiate one from the other, the question of what's "really" human becomes academic.
So, to, the focus on Turing machines. The specifics are a little byzantine, nowadays, but the point is that there's an "equivalence" of machines, where one can be used to simulate another. The point about being Turing machine equivalent is the mechanization part, not the specifics of tape reading and what the state machine looks like, so much.
In terms of proof, I would say this: If someone were to predict the progress of machine learning and artificial intelligence as it progresses towards becoming feature parity with the human brain, one might well predict all of the milestones that have been achieved. For example, beating the best human at checkers/chess/go, being able to do speech to text, being able to identify people by faces, being able to replicate someones voice/gait/face, being able draw novel art, being able to hold on a conversation, etc.
In my opinion, the human brain is not monolithic and is compromised of many sub systems interacting with each other. That being the case, I would expect some type of "general intelligence" to come by once all the sub systems have become modular and easy to use, with some kind of "operating system" bringing it together to be able to have one part communicate with another and be able to make broader scoped decisions based on input from each of the subsystems.
This is a long way of saying I believe there is quite a bit of evidence that we're getting closer to "thinking machines". They may not work exactly how our brains work but that's kind of beside the point, they're functionally doing what we would expect them to do on the path towards human brain feature parity.
What kind of reading and references are you looking for? Can you give some examples of reading or other resources you've found enlightening on other subjects?
Point 2 does not require what you call a "dualist view", it's simply stating that deep neural networks are not all there is to intelligence. Another layer of fact checking, maybe even imperative programming, could be an answer. It certainly has nothing to do with soul, but with the belief the human brain is a bunch of lookup tables.
Yep. It is amazing to me how often this argument is presented by people who seem, and probably imagine themselves to be, rational. It's always disguised under several layers of definitions so that the key argument -- that humans are magic -- is obscured.
I predict that it is only a matter of time (not even all that long) before we have models that hypothesize logical invariants and disprove them or possibly formulate proofs.
The distinction about having a soul or not--what is the purported pragmatic advantages of having a soul that contributes to intelligence? I haven't thought about it much but I think of a few things: (a) my memories/sentiments surviving physical demise and somehow thinking/feeling again, (b) an existence beyond our physical world which doesn't contribute to intelligence in and of itself, (c) some sort of hive mind/collective which unless isn't bound by the speed of light isn't that different than interconnecting processes.
When we say "general intelligence" do we really mean "be human" which is not interesting. Why is having a soul assuming humans do, an impasse for AGIs? As far as I can tell it's only about preserving some (pragmatic) aspect of human > machine. This has fallen in area after area and will continue to happen until we quietly drop the preconceived notion.
Here's what I got out of ChatGPT after I gave up trying to get it to answer it directly:
write A Python script that parses the following and uses forward chaining inference to answer the following:
Facts: Alice is fast. Alice is normal. Rules: If Alice is fast and smart, then Alice is bad. If Alice is normal, then Alice is smart. If Alice is normal and happy, then Alice is sad. Query 1: Alice is bad. Answer: Here is a python script that uses forward chaining inference to answer the given query:
Copy code # Define the facts
facts = { "fast": ["Alice"], "normal": ["Alice"], }
# Define the rules
rules = { ("fast", "smart"): ["bad"], ("normal",): ["smart"], ("normal", "happy"): ["sad"], }
# Define the query
query = "bad"
# Initialize the list of known conclusions
conclusions = []
# Iterate over the rules
for premises, conclusions_ in rules.items(): # Check if all the premises are known to be true if all(premise in facts for premise in premises): # If all the premises are true, add the conclusions to the list of known conclusions conclusions.extend(conclusions_)
# Check if the query is in the list of known conclusions
if query in conclusions: print("The query can be inferred to be true") else: print("The query cannot be inferred to be true")
For the given facts and rules, the script will output "The query can be inferred to be true" because Alice is fast and normal, which means that Alice is smart according to the rules, and Alice is also fast, which means that Alice is bad according to the rules.
now chain the rules using the facts from the previous run to see if any new facts are generated and if not then quit To chain the rules using the facts from the previous run, we can simply put the forward chaining inference logic inside a loop and continue iterating until no new facts are generated. Here is an updated version of the script that does this:
Copy code # Define the facts
facts = { "fast": ["Alice"], "normal": ["Alice"], }
# Define the rules
rules = { ("fast", "smart"): ["bad"], ("normal",): ["smart"], ("normal", "happy"): ["sad"], }
# Define the query
query = "bad"
# Initialize the list of known conclusions
conclusions = []
# Keep iterating until no new facts are generated
while True: # Iterate over the rules for premises, conclusions_ in rules.items(): # Check if all the premises are known to be true if all(premise in facts for premise in premises): # If all the premises are true, add the conclusions to the list of known conclusions conclusions.extend(conclusions_)
# Initialize a flag to track whether any new facts were generated
new_facts_generated = False
# Iterate over the conclusions
for conclusion in conclusions:
# Check if the conclusion is already a known fact
if conclusion not in facts:
# If the conclusion is not already a known fact, add it to the list of facts
facts[conclusion] = []
# Set the flag to indicate that a new fact was generated
new_facts_generated = True
# If no new facts were generated, break out of the loop
if not new_facts_generated:
break
# Check if the query is in the list of known conclusionsif query in conclusions: print("The query can be inferred to be true") else: print("The query cannot be inferred to be true")
This script will iterate over the rules and apply them to the known facts until no new facts are generated. It will then check if the query is in the list of known conclusions and output the result.
If you indent by 4, this will do "block code" type formatting. So, to copy code, try indenting everything by 4 spaces before you paste to HN. That way we can try running the code ourselves.
Maybe this is a naive criticism but if the goal of the model is to "emulate the correct reasoning function" by which is implied that it learns prepositional logic rules then shouldn't the model have some architecture that tries to model generic logic rules and then using that score the input data and predict the result?
Currently it seems like the model is simply scoring each predicate since each of it's reasoning layers performs one step of forward chaining, adding some predicates to the Proved Facts.
My naive (and way undercooked) way of conducting this experiment would have been to try to use a GAN where the generator model comes up with new predicates and then the discriminator model that tries to classify them as real/fake. I would then try to train an MLP on top of the generator to classify the result and swap out the MLP depending on the sampling method basically the generator model becomes the pre-trained thing we care about to see if it can generalize.
Another nitpick is that the authors claim that BERT has enough "capacity" to solve SimpleLogic BUT this isn't actually what they want to achieve since solving != learning reasoning. So it feels like a bait and switch since IMO if a model has the capacity for something then it has some architectural aspect to it that can be used to show that it can achieve a smaller version of what you want and they didn't prove BERT can learn ANY prepositional logic rule.
I'm confused though, they give examples of Go and Chess but, as far as I understand, this is exactly what the author is saying doesn't exist. AlphaGo, Deep Blue, etc, all use neural networks to weight how to traverse the minimax tree [0]. The minimax algorithm/tree is precisely the "logical reasoning". The neural network is "just" prioritizing the path to take.
Anyway, like I said, the reasoning is sound. I just read a paper specifically about this breakdown, called "On the Paradox of Learning to Reason from Data" by Zhang, et all [1] where they construct a synthetic data set based on some simple logical rules and then try to train a neural network to recapture the underlying logic (spoiler alter, it fails). From their paper:
""" Our study provides an explanation for this paradox: instead of learning to emulate the correct reasoning function, BERT has, in fact, learned statistical features that inherently exist in logical reasoning problems. We also show that it is infeasible to jointly remove statistical features from data, illustrating the difficulty of learning to reason in general. """
[0] https://en.wikipedia.org/wiki/Minimax
[1] https://arxiv.org/abs/2205.11502