Why collision avoidance is harder for an AI-based system

So in your mind the difference between AI (which you define very loosely) and any other program is just the scope and complexity.

>Lot of software can indeed be classified as (very weak) AI, because it makes decisions in service of a goal.

So take GNU make for example. It makes decisions of what to build in service of the goal of building some target you specified. Is GNU make an AI? By this definition it would be.

>At the very lowest end I could include some closed-loop control as AI (a simple proportional controller wouldn't count, a PID might).

Why would artifical intelligence have any requirement of runnig continuously? Is this a requirement for intelligence or is it just an arbitrary requirement you came up with to narrow down your very loose definition of AI? Now is Nginx an AI? It runs continuously and makes decisions of what to serve over HTTP. How about Bays spam filters? Those run contiuously (at least some of them) and make decisions of what to classify as spam.

>The more complex the model it has of the environment, and it's own effect on the environment, the more useful it is to call it an AI.

Making the complexity a requirement for AI is a bit silly as well. What if someone comes up with a very simple way of building an artificial intelligence? Just smells like you want to be able to use "it's not complex enough" as an argument for things that would otherwise fit your definition of AI. The problem with your definition seems to be that it doesn't include intelligence.

>ABS is lower than I would normally consider AI to be a useful descriptor because of how little information processing occurs (basically just wheel speed and brake pedal trajectory).

This is exactly what I mean.

>anything that autonomously makes intelligent decisions in response to changing environments.

So now you're trying to bandaid the definition even more. In the beginning of your comment your AI didn't require any intelligence but now it has to make intelligent decisions. How about you define intelligence before you start defining artificial intellgence? But this still wouldn't disqualify an ABS from your definition of AI since it most certainly does make intellignet decisions autonymously in response to changing environments.

I'm not patching up the definition -- I'm refusing to give a definition. As a consolation prize, I'm giving examples and discussing the degree to which they fit the central concept.

My stance is that "AI or not" is not an inherent way of dividing up systems in the universe. The best attempt to answer will provide a degree, rather than a binary yes/no. Further, the degree is based on utility to humans to think about the system that way. Thus no bright line, and a multitude of context-dependent factors that weigh towards or against it. If you must force a cut-off somewhere, then that threshold is context-dependent too.

>> I think we have very different definitions on what a feature is. You can use these activations as features in a model.

Let me backtrack a bit, to where I phrased the issue thusly:

Say, if you train a machine learning classifier C1 to recognise class Y1 from features F1,...,Fn, you can't then take the model of Y1 built by C1 and give it to a different classifier, C2, as a feature in a new feature vector Fn+1,...,Fn+k to learn a different class, Y2.

When you train a statistical machine learning classifier - let's take a simple linear model as an example, for simplicity; what you get in the output is a vector of numbers- parameters to a function. That's your model.

You can't use this vector of numbers as a feature. It is not the value of any one attribute - it's a set of parameters. So you can't just add it to your existing features, because your features are the values of attributes and the model is a set of parameters meant to be combined with those attributes.

What you can do is take your newly trained model and label the instances you have so far with the class labels the model can assign to them. Now, that's a pipeline alright. For instance, if you had a linear model with features "height" and "weight" and learned to label instances with "1" for male and "-1" for female, you could then go through your data, label every instance with a "1" or "-1" and then train again to learn a model of "age". At that point you have a new feature that is not the concept you learned in a previous session, but only a subset of that concept. Now you can try to learn a new concept from this new set of features, but the original concept ("sex") may or may not be part of it. It may turn out that "sex" is not necessary for learning "age" (it's redundant); or, it may be necessary, but in that case you have to learn the concept of "sex" all over again as part of learning "age".

By contrast, the class of algorithms I study, Inductive Logic Programming algorithms, can add the models they learn to their features (features are called "background knowledge" in ILP) and go on learning. For instance, such an algorithm can learn "parent" from examples of "father" and "mother", then "grandfather" from the original examples of "father" and the learned concept "parent" and "grandmother" from "mother" and "parent", then "grandparent" from "grandfather" and "grandmother" etc. Every time the new concept learned can be added to the learning algorithm's store of background knowledge, as it is- you don't need to go through the data and label it. That's because the representation of "data" and "concept" is the same, so you can interchange them at will.

Say, your background knowledge on "father" and "mother" might look like this:

  father(Earendil, Tuor)
  mother(Earendil, Idril)

From that you can learn "parent" that might look something like this:

  parent(A,B) :- father(A,B).
  parent(A,B) :- mother(A,B).

Now, you can add "parent" to your background knowledge, like this:

  father(Earendil, Tuor)
  mother(Earendil, Idril)
  parent(A,B) :- father(A,B).
  parent(A,B) :- mother(A,B).

From that you can learn "grandfather" and "grandmother" and add them to your background knowledge:

  father(Earendil, Tuor)
  mother(Earendil, Idril)
  parent(A,B) :- father(A,B).
  parent(A,B) :- mother(A,B).
  grandfather(A,B) :- father(A,C), parent(C,B).
  grandmother(A,B) :- mother(A,C), parent(C,B).

And then learn "grandparent" from that:

  father(Earendil, Tuor)
  mother(Earendil, Idril)
  parent(A,B) :- father(A,B).
  parent(A,B) :- mother(A,B).
  grandfather(A,B) :- father(A,C), parent(C,B).
  grandmother(A,B) :- mother(A,C), parent(C,B).
  grandparent(A,B) :- grandfather(A,B).
  grandparent(A,B) :- grandmother(A,B).

And so on.

That is what I mean by "composition"- building up knowledge by adding new concepts to your representation of the world.