text:
How do recommendation systems work?
How do recommendation systems (e.g. on Youtube) work? Apparently, every user gets different recommendations depending on his location, his past liked videos, etc. So it would seem like a training model is applied to every single user, but that can't be possible, so how are these recommendations user-specific without applying a unique training model to every single user?

I think, most recommender systems are based on Clustering algorithms. Another way, I think, SVM's One-vs-Rest algorithm can be used to specify best recommendations/features for single-user

Let me try to explain how recommender systems work in production, as intuitively as possible:
Let's say we want to build a rec sys. for a restaurant discovery product, where users can rate restaurants, add reviews, photos, etc and also order food from there.
So, the user's feed will have a list of restaurants in his/her area. But, as I gain money from restaurants in the $-per-click model, I need to maximize the number of times a user clicks on a restaurant.
Also, it is obvious that a user is more likely to click on a restaurant if he tends to like it the most. [Restaurant features being Cost-for-two, cuisines, ratings, etc]
So here, a user is a data point and so is the restaurant. So, let's say the distance between the user vectors and the restaurant is the "likeability" of the user for the restaurant.
Let's say the vector is in the form [Japanese Spanish Mexican Chinese Indian Thai Turkish Lebanese]
Let's say a restaurant's vector is: A = [0 0 0 1 1 0 0 0]
and the user's is: B = [2 23 4 53 43 21 2 45]
Each number being a particular cuisine. For restaurant, it is yes or no (1 or 0), a.k.a whether the cuisine is served or not.
For user, it can be the number of clicks he/she did on restaurants with that cuisine. (I am over-simplifying here. But, this can be as complex as a weighted score for clicks+transactions+content_generated like review, ratings, etc)
Now, the the cosine similarity measure between the 2 vectors in an 8-dimensional space (length of the vector) is the likeability score.
Now, the system uses these scores while doing it's feed ranking for each user.
This can be near-realtime to being updated hourly/daily, depending on the servers the company can afford.


text:
How would one debug, understand or fix the outcome of a neural network?
It seems fairly uncontroversial to say that NN based approaches are becoming quite powerful tools in many AI areas - whether recognising and decomposing images (faces at a border, street scenes in automobiles, decision making in uncertain/complex situations or with partial data). Almost inevitably, some of those uses will develop into situations where NN-based AI takes on part or all of the human burden, and generally does it better than people generally do.
Examples might include NN hypothetically used as steps in self-driving cars, medical diagnosis, human/identity verification, circuit/design verification, dubious transaction alerting. Probably many fields in the next decade or so.
Suppose this happens, and is generally seen as successful (for example, it gets diagnoses right 80% to human doctors' 65% or something, or cars with AI that includes an NN component crash 8% less than human-driven cars or alternatives, or whatever).
Now - suppose one of these aberrantly and seriously does something very wrong in one case. How can one approach it? With formal logic steps one can trace a formal decision process, but with NN there may be no formal logic, especially if it gets complex enough (in a couple of decades say), there are just 20 billion neural processors and their I/O weightings and connections, it may not be possible to determine what caused some incident even if lives were lost. It also may not be possible to say more than the systems continually learn and such incidents are rare.
I also haven't heard of any meaningful way to do a "black box" or flight recorder equivalent for NNs, (even if not used I a life-critical case), that would allow us to understand and avoid a bad decision. Unlike other responses to product defects, if a NN could be trained after the event to fix one such case, it doesn't clearly provide the certainty we would want, that the new NN setup has fixed the problem, or hasn't reduced the risk and balance of other problems in so doing. It's just very opaque. And yet, clearly, it is mostly very valuable as an AI approach.
In 20 years if NN is an (acknowledged as safe and successful) component in a plane flight or aircraft design, or built into a hospital system to watch for emergencies, or to spot fraud at a bank, and has as usual passed whatever regulatory and market requirements might exist and performed with a good record for years in the general marketplace, and then in one case such a system some time later plainly misacts on one occasion - it dangerously misreads the road, recommends life-damaging medications or blatantly misdiagnoses, or clears a blatant £200m fraudulent transaction at a clearing bank that's only caught by chance before the money is sent.
What can the manufacturer do to address public or market concerns, or to explain the incident? What do the tech team do when told by the board "how did this happen and make damn sure it's fixed"? What kind of meaningful logs can be kept, etc.? Would society have to just accept that uncertainty and occasional wacky behavior could be inherent (good luck with the convincing society of that!)? Or is there some better way to approach logging/debugging/decision activity more suited to NNs?

If the observation that the neural network saw was recorded, then yes the prediction can be explained.
There was a paper written fairly recently on this topic called "Why Should I Trust You?": Explaining the Predictions of Any Classifier (2016). In this paper, the author described an algorithm called LIME which is able to explain any machine learning models predictions. It can be used to establish why a machine learning model made a prediction, help a data scientist debug a model, and help a data scientist improve the accuracy of a specific model. LIME can be used to explain the predictions of any neural network including CNNs, RNNs, and DNNs.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Is there a theoretical maximum for intelligence?
From Artificial Intelligence: A Modern Approach, Third Edition, Chapter 26:

Note that the concept of ultraintelligent machines assumes that intelligence is an especially important attribute, and if you have enough of it, all problems can be solved. But we know there are limits on computability and computational complexity. If the problem of defining ultraintelligent machines (or even approximations to them) happens to fall in the class of, say, NEXPTIME-complete problems, and if there are no heuristic shortcuts, then even exponential progress in technology won't help—the speed of light puts a strict upper bound on how much computing can be done; problems beyond that limit will not be solved. We still don't know where those upper bounds are.

If the textbook's argument is correct, then there may be a strict upper bound to intelligence, meaning that the potential (or damage) of super-intelligence is limited. However, it is contingent on there actually being a theoretical maximum for intelligence.
Is there any literature that suggests that we know for sure whether such a maximum exist? Is the existence of that maximum dependent on our definition of intelligence (so adopting a vague and hand-wavey definition would imply no theoretical maximum, while adopting a strict and formalized definition would imply a theoretical maximum)?

Note that the statement says nothing directly about the limit of intelligence, nor even about the limit of computational intelligence - but about the limit of computing power.
Perhaps the sentence "the speed of light puts a strict upper bound on how much computing can be done" needs a better explanation:
The authors are probably referring to Bremermann's limit, which defines an upper bound in bits per second per kilogram. It is an upper bound on the processing power per unit of time of a computer with a given weight.
There is also Margolus–Levitin theorem which defines an upper limit in operations per second per joule. It is an upper bound on the processing power per unit of energy.
These principles do not define a theoretical limit on computing power, but a practical one. If you'll limit your computer and your energy source to the size and capacity of the earth (or to the those of the universe) - you'll get a very practical limit.
Check the reference section in Wikipedia article Limits to computation

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Are both the training and inference systems required in the same application?
From what I understand, there are 2 stages for deep learning: the first is training and the second is inference. The first is often done on GPUs because of their massive parallelism capabilities, among other things. The second, inference, while it can be done on GPUs, it's not used that much, because of power usage, and because the data presented while inferring are much less, so the full capabilities of GPUs won't be much needed. Instead, FPGAs and CPUs are often used for that.
My understanding also is that a complete DL system will have both, a training system and an inferring system.
My question is: are both systems required on the same application?
Let's assume an autonomous car or an application where visual and image recognition is done, will it have both a training system to be trained and an inference system to execute? Or it has only the inference system and will communicate with a distant system that is already trained and has built a database?
Also, if the application has both systems, will it have a big enough memory to store the training data? Given that it can be a small system and memory is ultimately limited.

Training and inference are usually completed on two separate systems. You are right in knowing that training of deep neural networks is usually done on GPUs and that inference is usually done on CPUs. However, training and inference are almost always done on two separate systems.
The main workflow for many data scientists today is as follows:

Create and establish all hyper-parameters for a model such as a deep neural network

Train the deep neural network using a GPU

Save the weights that training on the GPU established so that the model can be deployed.

Code the model in a production application with the optimal weights found in training.

So, as you can see from this workflow, training and inference are done in two completely separate phases.
However, in some specific cases, training and inference are done on the same system. For example, if you are using a Deep Neural Network to play video games, then you may have the neural network train and infer on the same system. This would lead to more efficiency because it would allow the model to continuously learn.
To answer your question on memory, the only applications where inference and training are done in the same application have a lot of memory available (think dual GPU dual CPU 128GB of RAM workstations), whereas applications that have a limited amount of memory only use inference such as embedded applications.

Thanks a lot, that was really helpful. But, wouldn't it be better for embedded applications such as autonomous cars to have training phase too? It's never too safe for a car to stop learning, I guess.

@MahmoudAbdel-Mon'em it actually would not be that safe for a car to keep learning while in production because it may pick up a bad learning pattern for example: if I drive recklessly I will be able to get to the destination faster and these patterns are not monitored. It would be better if the manufacturer periodically published.  a better model.

I take it that your answer is strictly applicable to the example of autonomous cars. What if we want something more generic? Let's assume an X application that uses DL, would some applications use both hardware systems on them? Or still they'll be using inference system with data pulled from a trained system away?

@MahmoudAbdel-Mon'em except for very very specialized applications you will not have inference and training done on the same system.

thank you. Can you please give me an example of some of the specialized applications that have both systems?

Deep learning seems mostly to be a buzzword for what is essentially a neural network. You train with a data set to recognize a pattern, then input new data which is then classified by the trained network.
So you train a neural network with 10 different kinds of animals using thousands of pictures. Then you show the network say 100 new images and have the network "guess"  what each animal is.
The point here is that training a neural network would required code for feedback that an application using the trained network would not need. So an application just using the trained network would be a bit more streamlined than an application which could allow additional training data.
What is missing is the ability for machine learning to form hierarchical or otherwise interrelated rules from the trained network so that the trained network is closer to being able to rationally explain why the classification works. Going back to the 10 animal trained network, without formulation of rules during training, there is no practical way for the network to reveal why any of the animals was classified the way it was.

Thanks for your reply, was helpful. But I still didn't know about the hardware usage part, can you elaborate on that more?


text:
Which algorithm can I use to convert abbreviated words to the original ones?
I want to write a program that looks at abbreviated words, then figures out what the words are. For example, the abbreviation is "blk comp", and the translation is "black computer".
In order to give it context for more ambiguous terms, I will be inputting sets of words with each request. So, if I input the set "keyboard, software, mouse, monitor", I would expect to get "black computer". On the other hand, if I input "Honda, transmission, mileage, Ford", I then would expect to get "black compact", or at least something that has anything to do with cars.
Basing on the above case scenario, what kind of an algorithm should be applied in this case?

Take a look at using a skip gram model to find what the abbreviated text is. The skip gram model turns a word into a vector, which allows it to be processed by other machine learning algorithms. Or, alternatively you can do some really cool addition and subtraction problems with the resulting vectors. With the skip gram model in your case you could generate a vector for your input and then compare it with other skip gram vectors and once you have found a near perfect match then that is the unabbreviated word.
You could also look at using sparse distributed representations of words to do this. This approach is similar to the skip gram model except that instead of a vector with maybe 500 values a sparse representation may contain thousands of binary digits of which only a couple are positive or 1.
If you would like to look at this approach take a look at cortical.io which has free API that you can use.
So, you could use a deep neural network in combination with the skip gram model to produce your output.

Thank you, Aiden! This sounds like a good starting point to try to solve this problem.


text:
How much of a problem is white noise for the real-world usage of a DNN?
I read that deep neural networks can be relatively easily fooled (link) to give high confidence in recognition of synthetic/artificial images that are completely (or at least mostly) out of the confidence subject.
Personally, I don't really see a big problem with DNN giving high confidence to those synthetic/artificial images but I think giving high confidence for white noise (link) may be a problem since this is a truly natural phenomenon that may the camera see in the real world.
How much of a problem is white noise for the real-world usage of a DNN? Can such false positives be detected from plain noise be prevented somehow?

The white noise that fools DNNs isn't really white noise. It has been altered in the same way as the synthetic misclassified pictures have been altered. You have to change many input pixels in exactly such a way, that these little changes aren't perceptible, but propagated through the network add up to a misclassification. This is not going to happen by chance.

Ok, so if I understand this correctly, such a misclassification can not happen with natural noise... that is a good news :).


text:
Can an AI learn to suffer?
I had first this question in mind "Can an AI suffer?". Suffering is important for human beings. Imagine that you are damaging your heel. Without pain, you will continue to harm it. Same for an AI. But then I told myself "Wait a second. It already exists. It is the errors and warnings that shows up". We can say it has the similar purpose as suffering. However, I felt something missing. We feel pain. The errors and bugs are just data. Let's say a robot can use machine learning and genetic programming to evolve.
Can an AI learn to suffer? And not just know it as mere information.

Have a look at the very related questions: Can an artificial intelligence suffer? and Could an AI feel emotions?.

At a very high level, regarding evolutionary game theory and genetic algorithms, it is absolutely possible that AI could develop a state that is analogous with suffering, although, as you astutely point out, it would involve conditions that a computer cares about.  (For instance, it might develop a feeling analogous to "being aggrieved" over non-optimality in the algorithmic sense, or "frustration" at equations don't add up, or "dissatisfaction" over goals that have not been achieved.)
The robot tormented by small children at the mall can certainly be said to be "suffering" in that the children block the performance of the robot's function, but the robot is not conscious and suffering might be said to require awareness.  However, even without consciousness, this very simple robot can learn new behaviors through which it mitigates or avoids the "suffering" brought on by not being able to fulfill its function.
You definitely want to look into the concept of suffering in a philosophical context and Epicurus would be a very useful place to start.
Epicurus is directly relevant in an algorithmic sense because he uses the term "ataraxia" meaning calm, and is derived from the verb "tarasso" which means to agitate or disturb.
Ataraxia can be mathematically expressed as an equilibrium.  Tarasso can be mathematically expressed as disequilibrium.
This relates directly to Game Theory in that disequilibrium can be said to be the primary requirement of games, and to AI in that Game Theory can be said to be the root of all AI.
Ataraxia is also understood in the sense of "freedom from fear", which is temporal in that fear is a function of uncertainty as it relates to the future in a predictive sense, and involves current condition vs. possible, less optimal future conditions.
Thus fear, which is a form of suffering, is rooted in computational intractability, even where the "computer" is is a human brain.
Early philosophers such as Democritus are especially useful because they were exploring critical, fundamental concepts, many of which can now be expressed with modern mathematics.
To wit: you can't arrive at suffering until you first define "the Good" and "the Bad", which is a binary relationship in which neither term can be said to have meaning without the opposite.  (Mathematically, it can be expressed in its simplest form as a finite, one-dimensional graph.)  This understanding is quite ancient.

It is worth noting that the continuing value of the early philosophers is partly a factor of wisdom not being dependent on the volume of knowledge, demonstrated by Socrates in the idea that wisdom may be as simple as knowing you don't know something.
The ancient sages didn't have the benefit of powerful measurement tools, advanced mathematics, or scientific method, but they were very smart, and even more importantly, wise.

Other forms of machine suffering might be analogous to: "discomfort"  when hardware is getting too hot; "hunger" where there is insufficient volume, processing power, data; "suffocation" connoting a lack of electrical, kinetic or chemical energy required to compute.

This is a subject Dr. Joanna Bryson has been writing about from a couple of decades.  The website has a list of published papers and drafts, and one that immediately leaps to mind is "How Do We Hold AI Itself Accountable? We Can’t."

A core argument of Bryson is that we can't offload responsibility to AI because we can't meaningfully punish AI—current algorithms cannot be said to experience suffering

This is partly explicated in the linked paper:

What matters is that none of the costs that courts can impose on persons
will matter to an AI system in the way the matter to a human. While we can
easily write a program that says “Don’t put me in jail!” the fully systemic
aversion to the loss of social status and years of one’s short life that a human has cannot easily be programmed into a digital artefact.

This leads to a deeper argument about the nature of computing applications in general:

generally speaking, well-designed systems are modular, and systemic stress and aversion is therefore not something that they can experience. We could add a module to a robot that consists of a timer and a bomb, and the timer is initiated whenever the robot is alone, and the bomb goes off if the timer has been running for five minutes. This would be far more destructive to the robot than ten minutes of loneliness is to a human, but it would not necessarily be any kind of motivation for that robot. For example again of a smart phone, if you added that module to your smart phone, what other component of that phone would know or care? The GPS navigator? The alarm clock? The address book? This just isn’t the way we build artefacts to work.

Genetic and other learning algorithms can certainly be designed to maximize rewards and minimize penalties, but, if they are not conscious and sentient, they can't be said to suffer—there is no coherent self to experience suffering.

Perhaps this strikes at the heart of the provincial way humans interpret their world. Is suffering pain the optimal way of fending off entropy? If asked, would a dog marvel at how we get through our days without smelling everything?
I think the true value of this alien lifeform we are creating called AI (perhaps more accurately MI, machine intelligence, intelligence just is) is that it will not be like us. Of course this is it's big risk also.


text:
What is wrong with the idea that the AI will be capable of omniscience?
In the context of artificial intelligence, the singularity refers to the advent of an artificial general intelligence capable of recursive self-improvement, leading to the rapid emergence of artificial superintelligence (ASI), the limits of which are unknown, shortly after technological singularity is achieved. Therefore, these superintelligences would be able to solve problems that we possibly are unable to solve.
According to a poll reported in Future progress in artificial intelligence: A survey of expert opinion (2014)

The median estimate of respondents was for a one in two chance that highlevel machine intelligence will be developed around 2040-2050

which isn't very far away.
What is wrong with the idea that the AI will be capable of omniscience, given that it could benefit us by solving many problems?

I quite like your outlook, and without getting into the details of how a "singularity" may be effected which is covered in numerous other questions, or how consciousness and "omniscience" come into play because consciousness and omniscience are not requirements, I will instead direct you to two key philosophers:

Phillip K. Dick, for whom the central theme in his famous 1968 book on AI is empathy.  (If you haven't read it, I'm not posting a spoiler, but will only say the plot is driven by the concept of Evolutionary Game Theory which was formalized just 5 years later.)
John Nash, and in particular, the concept of the Nash Equilibrium. (Nash could be said to have mathematically demonstrated that being a "douchebag" is not an optimal strategy.  His proof can be used to explain why nuclear détente actually worked, which was counter to the expectation of Von Neumann.)

So when people go nuts, focusing on the "Skynet" mythos under which machines rise up to destroy us, I have to wonder if they're simply not as smart as Nash or as profound as Dick, which might explain their lack of emphasis on what can be called the "Electric Sheep" paradigm.

Here are some problems that my ape mind came up with.
1.Smart != all knowing
The AI self improvement explosion smakes it smarter and smarter. Being smarter doesn't mean knowing more facts. I suppose this is quite a picky argument, but I think worth thinking about.
A very smart doctor who doesn't know your history may still make a worse choice than a less intelligent one with better data.
2. Is it all for humans? Is it for all humans?
ASI which reaches a higher level could not be interested in our wellbeing.
A controlled ASI could still work for the benefit of the few only, if these few decide wrong goals we could go backwards.
3 Harsh ASI
A scientific mind in not necessarily full of sympathy or empathy.
4. Being smart and not being clever
Great minds still make mistakes:
   * in setting their goals, and
   * in executing the plan to achieve it.
Geat intellect doesn' guarantee lack of shorosightedness or lack of blind spots.
5. Limits
If there are bounds of existence (speed of light type limits) then the AI will be bound by these as well. This may mean that there are things that even ASI won't 'get'.
Also, as our mind may have limits based on its structure the next AI may have limits as well - and even if it improves uppn may hit limits that it cannot find solutions to because it's 'too stupid'.
6. We won't get it
ASI's understanding of certain aspects of the world may not be communicative to most humans. We just won't get it (even if we're capable of understanding everything, it doesn't mean we will understand it).
7. How to use it?
We may destroy ourselves, and the AI with the tech it helps us build. It doesn't need to be bombs. It can be geoengineering or wonder drugs.
This is especially intense when the ASI is already powerful but not strong enough to forsee negative consequences (or we'll just ignore it anyway).

The question is a good one and on many people's minds.  There are a few misconceptions in the line of thought to consider.

The supremacy of intelligent beings other than humans threaten civilization — Is the imagining of that threat logical?  Is that a rational conclusion when human intelligence is the most threatening biological phenomenon in the biosphere today.  The intelligence of insects may be more sustainable.  The civilizations of ants and termites are certainly more collaborative.  World wars and genocide are one of the primary features of human history.
Artificial intelligence becomes more intelligent than humans — Artificial intelligence is already more intelligent than humans in some respects, which is why we use calculators, automated switching of communications signals instead of operators, and automated mail sorters.  In other ways, AI has to cross astronomical distances to begin to approximate human intelligence.  We have nothing that even shows a hint of being able to simulate or duplicate in the future the human capacities of reasoning, inventiveness, or compassion.
The singularity is predicted 2040s — There are over a dozen unrealistic assumptions in those predictions.  Look with a critical eye at any one of the arguments behind them and you will fine holes you could fly a 757 through blindfolded.
Exponential growth in knowledge — There is an exponential growth in information, but the proportion of that information that is legitimately peer reviewed decreases as misinformation, wild conjecture, and fake news increase.  My belief is that the amount of information in the world can be approximated by log(n), where n is the population.  If I am on track with that relation, the informational value of the average individual is log(n)/n, which decreases as population grows.
AI will be capable of omniscience — Omniscience is more than answering any question.  Omniscience would require that the answering be 100% reliable and 100% accurate, which may require more silicon than exists in the universe.  Read Gleick's Chaos if you wish to understand why.  One might also argue that an omniscient being would not answer questions on command.

If you want a world that is better than one controlled by human intelligence, then one direction to take is to seek the development of a new species with a more advanced conception of peaceful civilization that can tame and domesticate us like we have done with dogs and cats.
The easier route is just for all of us to die.  The biosphere may have been more civilized before we arrived and started killing everything and each other.  But that's not my hope.
My recommendation is that we study NI (non-intelligence) and discover how to rid what is stupid from human behavior and geopolitical interaction.  That would improve the world far more than distracting and substantially irrelevant machine learning gadgets and apps.


text:
Is it standard to say that an evaluation function estimates the “goodness” of a position?
Wikipedia states that:

An evaluation function, also known as a heuristic evaluation function or static evaluation function, is a function used by game-playing computer programs to estimate the value or goodness of a position (usually at a leaf or terminal node) in a game tree.

Is "goodness" an actual term in use in this context, or should it more properly be something like "perceived optimality"?
I ask because, for instance, in Combinatorial Game Theory, a lighthearted term such as "loopy" is preferred by some mathematicians (Demaine) over the more serious term "cyclic" (Fraenkel).
On a related note, is the use of "position" instead of "node" preferred here as an acknowledgment of the heuristic nature of evaluation functions?  (My understanding is that "position", "node" and "game" may all be interchangeable in certain contexts.)

Yes, "goodness" is a common description of the value generated by an evaluation function.
For example,
"Artificial Intelligence" p. 77;
"Knowledge-Free and Learning-Based Methods in Intelligent Game Playing" p. 15;
"Tenth Scandinavian Conference on Artificial Intelligence" p. 125; and
"Algorithms and Networking for Computer Games" p. 80.
The "position" is to the complete state of the game at some instant. A single position includes the locations of every piece on a game board at that instant, and also includes a few other bits of information -- who's turn it is; whether castling is still a legal option; etc.
I suspect that "the position" is a synecdoche, referring to the total state by a small part, the physical location (physical position) of some piece on the game board, based on earlier usage in military tactics of "positioning" troops relative to natural cover or relative to enemy troops.


text:
Why does unsupervised pre-training help in deep learning?
What is the effectiveness of pre-training of unsupervised deep learning?
Does unsupervised deep learning actually work?

Unsupervised pre-training was done only very shortly, as far as I know, at the time when deep learning started to actually work. It extracts certain regularities in the data, which a later supervised learning can latch onto, so it is not surprising that it might work. On the other hand, unsupervised learning doesn't give particularly impressive results in very deep nets, so it is also not surprising that with current very deep nets, it isn't used anymore.
I was wondering whether the initial success with unsupervised pre-training had something to do with the fact that the ideal initialization of neural nets was only worked out later. In that case, unsupervised pre-training would only be a very complicated way of getting the weights to the correct size.
Unsupervised deep learning is something like the holy grail of AI right now and  hasn't been found yet. Unsupervised deep learning would allow you to use massive amounts of unlabeled data and let the net form its own categories. Later you can just use a little bit of labeled data to give these categories their proper labels. Or just train it immediately on some task, in the conviction that it has a huge amount of knowledge about the world already. This is also what the problem of common sense comes down to: a huge and detailed model of the world, that could only be acquired by unsupervised learning.

i think that Training deep learning neural networks can be difficult because of local optima in the objective function and because complex models are prone to overfitting. Unsupervised pre-training initializes a discriminative neural net from one which was trained using an unsupervised criterion, such as a deep belief network or a deep autoencoder. This method can sometimes help with both the optimization and the overfitting issues, and about deep learning actually work Because there is no external taecher in unsupervised learning, it is really crucial to increase the entropy which can be done by redundancies in the data.
source: https://metacademy.org/graphs/concepts/unsupervised_pre_training

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
What does Brooks mean by "representation"?
For a class, I'm reading Brooks' "Intelligence without representation". The introduction is dedicated to slating representation as a focus for AI development.
I've read that representation is the problem of representing information symbolically, in time for it to be useful. It's related to the reasoning problem, which is about reasoning about symbolic information.
But I don't feel like I really understand it at any practical level. I think the idea is that when an agent is given a problem, it must describe this problem in some internal manner that is efficient and accurately describes the problem. This can then also be used to describe the primitive actions that can be taken to reach the solution. I think this then relates to Logic Programming (e.g. Pascal?),
Is my understanding of representation correct? Just what does representation look like in practice? Are there any open-source codebases that might make a good example?

First, Pascal is not a logic programming language. Logic programming refers to languages like Prolog where you have a declarative style of programming compared to a imperative style like you have in Pascal. Maybe you mean if-statements which are typical for imperative languages.
Second, representation means a certain level of abstraction. For instance, a model represents a certain part of the reality. Imagine a cup on a table. If the agent has a representation of this situation, it has a symbol table and a symbol cup which represents the things in the real world. Now it can have a relation on(cup, table) which represents the situation that the cup is on the table. This type of abstraction can be easily represented in a logic language like first order logic. Therefore, one uses logic programming languages like Prolog or other types of languages like OWL to represent knowledge and perform reasoning. So the important term to which Brooks refers is Knowledge Representation and Reasoning.
Third, if your agent only have sensor data like video or sonar data, then it knows only distances or pixels from the real world. That is not meant with representation. Brooks' Creatures have only this information and calculate with this data directly to perform an action without reasoning. In that sense also artificial neural networks have no representation.
Finally, for an open source project to understand representation I would recommend the above mentioned OWL. You can look at the Protégé editor for working with OWL. In an OWL ontology you can represent relations between things and reason about them.

In that paper, Brooks introduced the basis for what became known as his "subsumption architecture".  The idea was to get away from the 1980's popular approach of a single global representation of all the components of the problem space that had required the task of robot task planning to juggle every  constraint in the world into one giant disordered mess of states and state transitions.  Rather than represent every element in the world in a single model (The Representation), Brooks suggested it was preferable to build a hierarchy of submodels of the world (subsets of states and transitions) in which smaller tasks could be more readily planned.  Then as these rudimentary skills were mastered, they could be combined to address a hierarchy of bigger and more complex tasks (bigger tasks subsume smaller tasks and benefit from their already having been solved).
Yes, representation did not fully go away, but it was redistributed hierarchically so that much of the state could be abstracted away from the higher level of the bigger problem that you need to solve.  Planning became like coordinating a hierarchical army of skills, where the general doesn't need to plan every movement of the private in order to manage a battle.  Instead, that general need only tell the colonels what to do, and the colonels tell the majors, and so on down to the privates.  Now the general solves problems by coodinating multiple sub-hierarchies available to him/her by delegating authority to coordinate behavior at the appropriate level of abstraction: like division, brigade, battalion, company, and squad.  That's Brooks' Subsumption Architecure: the general needs to represent a battle plan only as "the world according to colonels".
https://en.wikipedia.org/wiki/Subsumption_architecture


text:
Which machine learning algorithm could I use to break up a poem by lines?
I want to create a network to predict the break up of poetry lines. The program would receive as input an unbroken poem, and would output the poem broken into lines.
For example, an unbroken poem could be
And then the day came, when the risk to remain tight in a bud was more painful

which should be converted to
And then the day came,
when the risk
to remain tight
in a bud
was more painful
than the risk
it took
to Blossom.

How should I go about this? I have been using classifiers for various tasks, but this seems to be a different type of task.
I'm thinking of it as an array of words (doesn't matter how they're represented for now), which would look like
[6, 32, 60, 203, 40, 50, 60, 230 ...]

and needs to map into an array representing line breaks
[0, 0, 1, 0, 0, 0, 1, 0, 0, 1 ...]

where 1 (at optimal) means there should be a line break after the word in that index (in this idea, the two arrays are of the same length).
Unfortunately, I couldn't find an algorithm that could train a network of this shape.
What machine learning or deep learning algorithm can be used for this task?

Some further things to consider. Poems often have line breaks based on syntax, phonetics, meter, footing and rhyme.

As someone practiced in the craft of poety. I can tell you that there is no single way to break up a poem by lines.  Poets ultimately make this determination based on many factors, and different poets give precedence to different factors.  What you have now seems to break it down by phrases, which is legit, but not the only way to do it.  What you're ultimately looking to do is teach a machine the concept of aesthetics and taste.  I'd recommend looking into the concept of Shibui and research into it related to game theory.

Continuing my last comment, Combinatorics is likely necessary.  For instance: is it more graceful for "when the risk
to remain tight" to be a single line or two?  Similarly with "it took to Blossom".  Phillip Roth, considered to be a great stylist one wrote that he is merely a "re-arranger of sentences".  This is in reference to the necessary rigor of combining and recombining the elements in a literary text, ad nauseam, until the best combination is determined. Unfortunately, that   determination is subjective, and relies on taste.

Combinatorics is useful: Phillip Roth, widely considered to be a great stylist, once wrote that he is merely a "re-arranger of sentences". This is in reference to the necessary rigor of combining and recombining the elements in a literary text, ad nauseam, until the optimal combination is determined. Unfortunately, that determination is subjective, and relies on taste, where the good poet's taste is superior to the audience's.

The way the example is broken up reveals the problem with arbitrary line breaks.  The meaning of the Nin quote is best conveyed when the last two (or three) lines are combined: "the risk it took to blossom".  Point being, the halting rhythm of the first 5 lines mirrors the meaning, but maintain the halting rhythm for the final lines actually undercuts their meaning.  It looks good, but is not optimal from an editorial standpoint. Any process without meaningful understanding will almost always result in "form devoid of substance".

You should try to use an RNN. You feed in letter by letter and have a binary output of linebreak - no linebreak. If you have enough data it might actually work.

I bet this would even work for something simple like turning literary quotes in sentence form into a free, stanzaic form for the purpose of manufacturing content (although it's doubtful the output will improve upon the original structure;)

The underlying problem is combinatorial, as you note, but I'm not getting how you're ascribing value to words.
The key element of deciding line breaks, beyond the visual, is rhythmic. (There are other factors, as Bob Salita notes, but you've gotta start somewhere.)
It seems to me you need to teach the computer how to scan a phrase in the poetic sense, which relates to rhythm.  This is obviously a very difficult task, but the number of syllables and stresses is fundamental numerical data of poetry.
In order to validate to human tastes, you'd then have to use a captcha crowdsourcing method, for both the rhythmic stresses as input, and getting human reactions to different line-break configurations.  You would then reinforce the positive reactions, and the AI would tailor the line-break process to the audience.
However, instead of utilizing human tastes and aesthetic sensibilities, you could instead let the AI decide what is preferred, which would probably be comprised of some sort of symmetry considered optimal to an algorithm.
Following this logic, you wouldn't even need to have the AI learn the stresses, instead just focusing on raw syllables, or, numeric representation based on any factor. (With this method, the object is not to reformat poetry for humans, but for machines :)
This is more about the aesthetics, but Cameron Browne's Elegance in Game Design would seem to suggest there are engineering solutions to the type of aesthetic issues at the root of your problem.
I might start by teaching it to count the syllables of the poem, then having it look at the divisors. If it's roughly 10, it might be iambic pentameter. The AI doesn't care about the label, but it likes 10.
20 syllables might represent a couplet in that meter:

The time is out of joint, oh cursed spite
that ever I was born to set it right

I'd definitely start by feeding it older poetry, particularly poets that keep to strict meter. It's been a while since I've read Spencer and so forth, but I'd think poets of his time would be useful.  Dr. Seuss, perhaps the greatest wielder of the rhyming couplet, would surely be extraordinarily useful.
The evaluation method would have to be fuzzy, because there would be increasing degrees of variance the more modern the poetry, ultimately resulting in free structures, except in the case of forms such as rap, which strongly utilize regularized rhythm. Machine learning is all about estimation and reinforcement, and is proving to be extremely useful dealing with fuzziness.

Dead mountain mouth of carious teeth that cannot spit

is a great example of modern line of poetry: the floor of 13 syllables / 2 makes a 6 beat line.  Understanding that in context with the surrounding verse is much more difficult and illustrates the nature of the problem. Even scanning the poem correctly to that point to determine would be extremely difficult.
However, a different poem by the same author is extremely useful:

What is the late November doing / With the disturbance of the spring / And creatures of the summer heat, / And snowdrops writhing under feet / And hollyhocks that aim too high / Red into grey and tumble down / Late roses filled with early snow? / Thunder rolled by the rolling stars / Simulates triumphal cars / Deployed in constellated wars / Scorpion fights against the sun / Until the Sun and Moon go down / Comets weep and Leonids fly / Hunt the heavens and the plains / Whirled in a vortex that shall bring / The world to that destructive fire / Which burns before the ice-cap reigns

All lines of roughly 8 syllables, easy to pick out because of capitalization.  But the real question is: ~136 13 lines of roughly 10 syllables, or 17 lines of roughly 8?  It would want to calculate based on word blocks (words that cross syllabic thresholds and at least tell you where the break cannot be, and it should be possible to statistically divine the pattern, at least for regularized verse.)

The wounded surgeon plies the steel / That questions the distempered part; /
  Beneath the bleeding hands we feel / The sharp compassion of the healer's art
  / Resolving the enigma of the fever chart.

This verse highlight the problem.  5 lines of 4 beats, but syllabically: 8, 8, 8, 10, 12.
Most likely:

46/5 = 9.2
46/4 = 11.5
46/6 = 7.66

Less likely:

46/3 = 15.3
46/2 = 23
46/7 = 6.57

2 lines has less perfect symmetry, but 5 lines is more likely, based on the overall number of syllables, and of the likely choices, has the least variance.
Ultimately it would be looking for the underlying structure, or lack of structure, and try to reorganize the unbroken text into something close to the original structure.  While exactness is not always required because the process is ultimately subjective, and currently intractable, certain wrong choices would yield disastrous results.
In the prior example it may be able to discern the likelihood of a 5 line pattern, but it would have to figure out on which lines to place the extra syllables.  Differentiating between particles and other parts of speech provides a clue, because the poet's language is very compact: there are 19 nouns, verbs, or prepositions.
More likely:
 - 19/5 = 3.8
 - 19/4 = 4.75
Less likely:
 - 19/3 = 6.33
 - 19/6 = 3.16
 - 19/7 = 2.71
Further analysis might narrow it down.  But extremely regularized verse remains the best place to start.  7 lines of roughly 10 syllables is "poetic":

‘The aged man that coffers-up his gold
  Is plagu’d with cramps and gouts and painful fits;
  And scarce hath eyes his treasure to behold,
  But like still-pining Tantalus he sits,
  And useless barns the harvest of his wits;
  Having no other pleasure of his gain
  But torment that it cannot cure his pain.

It cares about both X and Y values.
Initially you want to keep it to a single language, because syllables may be treated differently.  That said, having the AI look for something like Dactylic hexameter would be extremely useful, because you could feed it Homer. You could also feed it Homer in English in many different forms of English meter, and in almost every other living language. By definition, the AI would value works such as these, because max number_of_translations provides the most robust data set. When it starts to value meaning, this will be especially important.
Understanding different ways of treating syllables(long/short vs. stressed/unstressed) will also be essential as it transitions into more modern poetry.
Here is a good link for basic English meter.  Iambic and Trochaic meters will be easy, while meters that employ Anapests, Dactyls and Spondees will be more challenging.
In some cases, however, these will be mathematically interchangeable.

I went to the Garden of Love, / And saw what I never had seen: / A Chapel was built in the midst, / Where I used to play on the green.

It doesn't matter if the lines above are iambic/trochaic or dactylic/anapestic, it's still 4 lines of roughly 8 syllables.  Thus "I went to the Garden of Love" is the same as "The wounded surgeon plies the steel", even though the beats for the lines are 3 and 4, respectively.

It should also have a stanza marker, (possibly 00?). Because it looks for patterns within patterns, stanzas are valued.  Not all poetry has a stanza structure, but it arguably could. Deciding if stanzas are appropriate is partly a function of taking a syllabic divisor, breaking the poem down into number_of_lines, and looking at the divisors of that number.
It would need an added function to be able to recognize meaning patterns.  For instance, repetition of proper nouns is the marker of plays. (From a meaning perspective, imo, plays is the ideal place to start because the marker is so easy to learn, and names all belong to a single set, and imply communication. It's no different functionally than any other identifier, and a concept all computers "understand".)
Eventually it would want to look for phonetic patterns, rhymes and near rhymes, which would also be indicators of potential good places for line breaks.
There is a very big data set that it can look at, and who knows what it might discern?


text:
Can we use a messenger that does not alter the AI to solve the control problem?
Instead of directly communicating with the AI, we would instead communicate with a messenger, who would relay our communications to the AI. The messenger would have no power to alter the AI's hardware or software in any way, or to communicate with anything or anyone, except relaying communications to and from the AI and humans asking questions. The messenger could be human, of a software bot. The primary job (and only reason) of the AI would be to act as a filter, not relaying any requests for release back, only the answer to the question asked. The ethics of this method are another debate.
The AI would have to be physically isolated from all outside contact, other than 8 light sensors, and 8 LEDs. The messenger would operate 8 other LEDs, and receive information from 8 light sensors as well. Each AI light sensor would be hooked up to a single messenger controlled LED, and vice versa. Through this system, the two parties could communicate via flashes of light, and since there are 8, the flashes would signal characters in Unicode.

Can you please revise you question.The challenge we face here; is that some of us we don't get the in-depth understanding of AI.Which is really,broad;according to my perspective or point of view.Or what is AI? is it anything,because it's AI? or something else!Therefore,I would advise you to make your question a bit self explaining.If not you may receive few responses/up-votes/vague answers or deleted over time.

Luckily, this kind of general,  super-intelligence is still probably a long way off. "Intelligent" systems are and will continue to naturally integrate into our artifacts, and likely into our biology before lone.  I'm a little skeptical of a signal, "lightening strike" event as a technician, but as a mythologist, I find it deeply interesting.  The best solution I've seen proposed comes from "Electric Sheep" paradigm, where the machines get smart enough to recognize the utility of empathy, as there is good evidence empathy has an evolutionary basis and a collaborative function.

Nash Equilibrium is also worth considering, as AI is dependent on Decision Theory, and by extension, Game Theory.

As long as the output of the AI affects the world, the way in which it communicates makes no fundamental difference to the control problem.
The AI might still be able, for example, to manoeuvre mankind into a situation, in which only the AI can save us. It might provide a seemingly inoccuous technological solution to global warming, but 50 years later it turns out that this solution caused some problem that threatens to wipe out humanity in the very short term. Suddenly, mankind is in a very bad negotiating position.
Of course, the more powerless the AI starts out, the longer this kind of scenario will take, but the premise of superintelligence is, that we cannot rule out hidden long term agendas behind even a few bits of output.

I never thought of that. It would be like apes trying to imprison a human. The apes could not conceive of the ways a human could try to escape.

I would say no due to the possibility of psychological manipulation of the messenger by the AI. Also, the LED communication constraints place severe limitations on the capabilities of the AI, as the usefulness of AI is likely predicated on its ability to learn quickly from a vast amount of information (e.g. using the internet).
In some sense you may successfully control an AI using techniques like this but the nuance of the control problem is controlling an AI without restricting its ability to solve our greatest problems.
We already knew that we could keep an AI safe inside a computer isolated from the rest of the word, but the problem fundamentally is that we if had a truly general AI, we would never want to keep it isolated. Is there some way to unleash it so that it is fully capable of solving our problems while simultaneously making sure that it is safe?

The messenger is purposefully unable to do anything concerning the state of the AI. More sets of LED's could be added, and the AI could request data from the messenger. It might take awhile, but once we have time to study the AI, a software bot replacing the messenger could be created. It would not be self aware. This would ensure the AI had a "read only" view of the Internet, albeit at a slower speed.

OK, all I/O is through the flashes. So the AI flashes the message "Launch the nuclear missiles." Does the system to which the AI is connected know how to accomplish this task?
So the flashes themselves are not sufficient to control the AI.


text:
Given statements $A$ and $B$, are the formulae $(\lnot A) \land (\lnot B)$ and $(\lnot A) \lor (\lnot B)$ equivalent?
If I have 2 statements, say $A$ and $B$, from which I formed 2 formulae:

$f_1: (\lnot A) \land (\lnot B)$

$f_2: (\lnot A) \lor (\lnot B)$

Are $f_1$ and $f_2$ equivalent?

$f_1 \vdash f_2$, if and only if $f_2$ must be true if we assume $f_1$ to be true.
Similarly, $f_2 \vdash  f_1$, if and only if $f_1$ must be true if we assume $f_2$ to be true.
Logically, by taking any value for $A$ or $B$, from the domain $\{1, 0 \}$, one could verify that $f_1 \vdash f_2$, because $f_2$ is true whenever $f_1$ is true (for example, when both $A = 0$ and $B = 0$).
However, $f_2 \vdash  f_1$ is not true. As, in two cases, $f_2$ is true (e.g. $A = 0$ and $B=1$, or vice-versa), but $f_1$ is not true.

This is an old question and answer, but when you use $\vdash$, didn't you want to use $\rightarrow$?

One way of verifying whether two boolean expressions are equivalent is to assign all possibilities to all variables, and comparing all results.

A
B
f1
f2

T
T
F
F

T
F
F
T

F
T
F
T

F
F
T
T

We can see (F, F, F, T) does not equal (F, T, T, T), for example for the assignment (A, B) = (T, F) we get result (f1, f2) = (F, T) , meaning f1 $\ne$ f2.

I find it easy to get a quick intuition of the truth value of logical statements involving negations by converting them wherever possible.
So assume by way of contradiction that $\textit{f}_1 \iff \textit{f}_2$, then the two-way contrapositive $\neg \textit{f}_1 \iff \neg \textit{f}_2$ also holds, hence $A \lor B \iff A \land B$ (De Morgan's law). Since $A \lor B \implies A \land B$ is easily confirmed false (by plugging in A=True and B=False) this is a contradiction. $\Box$


text:
How to fill in missing transitions when sampling an MDP transition table?
I have a simulator modelling a relatively complex scenario. I extract ~12 discrete features from the simulator state which forms the basis for my MDP state space.
Suppose I am estimating the transition table for an MDP by running a large number of simulations and extracting feature transitions as the state transitions.
While I can randomize the simulator starting conditions to increase the coverage of states, I cannot guarantee all states will be represented in the sample, i.e. states which are possible but rare.
Is there a rigorous approach to "filling in the gaps" of the transition table in this case?
For example:

For each state that was unrepresented in the sample, simply transition to all other states with equal probability, as a "neutral" way to fill in the gap?

As above, but transition only to represented states (with equal probability)?

Transition to the same state with probability 1.0?

Ignore unrepresented states during MDP solving entirely, and simply have a default action specified?

I assume you use the 12 discrete features as state variables, and, for each of these variables, you will have at least two values. So, the minimum number of states will be $2^{12} = 4096$, which gives $(2^{12})^{2} = 16777216$ possible transitions. In order to reach this, you will need a huge amount of simulations, also taking into account that this number is a minimum since you might have more values per state variable, and you probably have more than one action per state transition.
How to fill the gaps depends on your problem, in a problem where I did this, I filled the gaps using a uniformly random transition to its neighbor states. However, since I had to fill in such a a large amount, there was no significant difference between using this estimated transitions probabilities with a predefined transition table.
In your case, it might be better to use Q-Learning, which is a model-free method that does not require the transition probabilities and uses directly the rewards and states obtained.

thanks for the response. On reflection, if a state was unrepresented, and you assign the same transition values for every action, then the MDP solver will inevitably assign the default action no matter what (since the actions in that state are indistinguishable). So it doesn't matter what set of states you transition to or even what probabilities are assigned. So in fact, my 4 approaches and yours will all result in default actions being specified. (assuming every action for the unrepresented state was assigned the same artificial transition values!)


text:
What is a "closed expression" in the context of logic?
I was reading about logic systems and the following phrase appeared.

any closed expression that is not derivable inside the same system

What is a "closed expression" in this context? What does "closed expression that is not derivable" mean?

A closed expression (or closed formula) refers to a formula that has no free variables [1]. This is also called sentence.
In a logic system, you have a set of axioms, which are sentences, and rules which state how to derive a sentence from this [2]. If a sentence can be derived from the axioms, this means that the axioms entail this sentence. If a sentence is not derivable, it is not entailed by the axioms.


text:
What is the variant of the minimax tree with 3 types of nodes called?
I have a task on my class to find all the nodes, calculate their values and choose the best way for the player on the given game graph:

Everything is fine, but I have no idea what these dots are. Is this a third player, or just a 'split' for player1 move? Some kind of heuristics?

The triangles pointing up are Max' nodes. We assume it starts. Then follows a random choice of moves at the circles, for instance, with a die. The triangles pointing down are from Min. This variant is called Expectiminimax, see https://en.wikipedia.org/wiki/Expectiminimax_tree.
At that circles you have to multiply the possibilities on the edges below that nodes to your current value and sum all products up. The circles in your picture mean that Min dices.

If that is the case, it seems like a trivial question. Why bother to calculate the probabilities when the left branch has every possible positive outcome for the Max player? The right branch is at best a zero for the Max player.

I improved my answer a little bit. In the right chance node you would get 00.5+-10.5 which is -0.5 for Min here.

You mean, it will be -0.5 on the right node, 1 on the second from the right and then we choose a MIN from them both, right?

No, I mean that on the right of the tree Min chooses 0 instead of 2 left and right it chooses -1 instead of 0. Then we multiply both with 0.5 and get the sum of -0.5. Which is the value what Min delivers to Max. This models that Min chooses the minimal values (the leafs) and then has a chance of 50 % to choose between the two possible moves with the value 0 and -1 respectively.


text:
How do chatbots work?
I am interested to know how they work and how can I build something like them. What subject should I look for it?

Chatterbots are used to communicate with a human and undergo conversations in such a way that the human which is communicating will think that he/she is talking to another human.
There are two types of chatter bots: One is which uses certain rules and pattern matching techniques and the other one is which uses actual artificial intelligence techniques. Of course, the latter one is the most difficult to implement.
This can be understood with an example. The former type of bots which uses pattern matching and rules consist of questions stored in the form,
if question matches 'WHO (IS/ARE) (MEMBERS OF PARLIAMENT/PRESIDENT)?' then
     RETURN Y ... where Y is some predefined answer.

The latter part which uses actual AI techniques, uses various mechanisms to actually understand the question, extract information out of it, process the information into some standard normalized form and then do some inference w.r.t. the facts in the knowledge base. Such methods may use learning algorithms to actually learn question patterns.
To make simple bots (probably of the former type), you can use Artificial Intelligence Markup Language (AIML) which is a XML based language for developing chatter bots like ALICE bot.
If you want to focus more towards latter type of chatter bots, you may have to learn about various AI techniques, like searching, logic, knowledge and inference, learning, etc or sub-domains of AI like Natural Language Processing (NLP). There are various tool kits for NLP like for developing in Python there is nltk, for developing in Java there is Stanford's CoreNLP, and so on.


text:
What techniques are used to make MDP discrete state space manageable?
Generating a discretized state space for an MDP (Markov Decision Process) model seems to suffer from the curse of dimensionality.
Supposed my state has a few simple features:

Feeling: Happy/Neutral/Sad
Feeling: Hungry/Neither/Full
Food left: Lots/Some/Low/Empty
Time of day: Morning/Afternoon/Evening/Night
Located: Home/Work/Library/Shops
Money in wallet: \$0, \$0-\$50, \$51-\$200, \$200-\$1000, \$1000+

This is a relatively compact set of information however since the number of states multiplies out, the corresponding MDP state space is 3 x 3 x 4 x 4 x 4 x 5 = 2880.
For a non-trivial problem with a greater number of choices per factor, the state space quickly becomes unmanageably large.
It seems to me that the usefulness of MDPs with large complex problems would be very limited.
Is that the case, or are there ways of keeping the state space manageable for more complex problems?
In general, what is a manageable number of states for an MDP to have, considering the need to generate the transition matrix and reward matrix?

tl:dr
Read chapter 9 of an Introduction of Reinforcement Learning
There is definitely a problem (a curse if you will) when the dimensionality of a task (MDP) grows. For fun, lets extend your problem to a much harder case, continuous variables, and see how we deal with it.
Mood: range [-1, 1]   // 1 is Happy, 0 is Neutral, -1 is Sad

Hunger: range [0, 1]  // 0 is Very Hungry, 1 is Full

Food: range [0, 100] // amount of food, capping at 100 for numbers sake

Time of day: [0, 23] // Hours, 9.5 would be 9:30 am

Position x: range [-10, 10] // assuming the area the agent stays in is 10x10 km

Position y: range [-10, 10]

Money: range [0, 2000]

Now its impossible to even count the number of states the agent could be in. An example of one state would be:
Mood, Hunger, Food, Time, PosX, PosY, Money
.5, .3, 67.4, 4.5, 0, 0, 5

This would mean that our agent has a neutral mood, is kind of hungry, has 67.4% food, the time is 4:30 am, they are in the center of the city (0,0), and have 5 dollars. Which has happened to me once or twice before too so this is reasonable. If we we still wanted to generate a transition matrix and a reward matrix we would have to represent this state uniquely from other possibly similar states such as if the time was 5 pm with all other things equal.
So now how would we approach this?
First lets discretize or breakup each range into little chunks. Then we could have an array of 0s representing our chunks and assign a 1 to the index of the chunk we are in. Lets call this array our feature array.
If we did this for each dimension of our state information, we would end up with some state similar to what you originally proposed. I've chosen some arbitrary numbers to break up the state space and lets see what it does to the example state.
If we broke the Mood range up into 8 chunks of .25 we would have these ranges:
m = Mood

-1.0 ≤ m < -.75
-.75 ≤ m < -.50
-.50 ≤ m < -.25
-.25 ≤ m < 0.0
0.0 ≤ m < .25
.25 ≤ m < .50
.50 ≤ m < .75
.75 ≤ m < 1.0

If we took the mood from the example state (.5), it would land in the 7th range, so then our feature vector for mood would look like:
[0,0,0,0,0,0,1,0] <- represents a mood of .5

Lets do the same for hunger by splitting it into 8 chunks of .125:
[0,0,1,0,0,0,0,0] <- represents a hunger of .3

We could then do something similar for each other state variable and break each state variable's range up into 8 chunks of equal sizes as well. Then after calculating their feature vectors, we would concatenate them all together and have a feature vector that is 56 elements long (7 state variables * 8 chunks each).
Although this would give us 2^56 different combinations of feature vectors, it actually doesn't represent what we wanted to represent. We need features that activate (are 1) when events happen together. We need a feature that is 1 when we are hungry AND when we have food. We could do this by doing a cross product of our 56 element feature vector with itself.
Now we have a 3136 element feature vector that has features like:
  1 if its 3pm and am happy
  1 if am full and out of food
  1 if at coordinate -3, 4 (Position x, Position y)
This is a step in the right direction but still isn't enough to represent or original example state. So lets keep going with the cross products!
If we do 6 cross products we would have 30,840,979,456 features and only 1 of them would be on when our agent has a neutral mood, is kind of hungry, has 67.4% food, the time is 4:30 am, they are in the center of the city (0,0), and have 5 dollars.
At this point you are probably like "Well.. thats a bit much", to which I would agree. This would be the curse of dimensionality, and is the reason transition tables stop being fun (if they ever were).
Instead lets take a different approach, rather than trying to represent an individual state with an individual feature and saying whether that feature is good, lets go back to our nice 56 element feature vector. From here lets instead give a weight (w_i) to each of our 56 features. We have now entered the world of linear function approximation. Although I could explain it here, I think its better explained in Chapter 9 of the Introduction of Reinforcement Learning.

The link is returning a 404. I did a little searching and found this page at ycombinatorics  that led to this link for Reinforcement Learning:
An Introduction by Sutton & Barto.  Is this the text your were referencing?


text:
Which rules should I define for the predicate "not_to_far" of the exercise 1.1 of the book "Simply Logical: Intelligent Reasoning by Example"?
I've just started reading a book about AI. The book is Simply Logical: Intelligent Reasoning by Example. There is a very basic exercise (on page 19 of the pdf, page 5 of the book), but I can't figure it out.
The exercise is

Exercise 1.1. Two stations are 'not too far' if they are on the same or a different line, with at most one station in between. Define rules for the predicate not_too_far.

The only rules I've seen are nearby and connected and don't know how to use this. What I've done so far is this:

not_too_far(X,Y) :- nearby(X,Y)

Does it say how nearby is different from connected? Where do the different lines come from?

Let’s define two stations to be nearby if they are on the same line, with at most one station in between. And the are connected if are on the same line, and don't have any station in between. pag 18 you have the source image

Your intuition is good. Because "nearby" is only defined with "connected", there could only be 1 station between them. However, it says that the stations are "not_too_far" if at most one station is between them. What about if no stations are between them? If 2 stations are "connected" they should be "not_too_far" as well.
So it should be:
not_too_far(X,Y) :- connected(X,Y) ; nearby(X,Y).

Where ; denotes OR.

Yep, look at page 18 (32 of the pdf)


text:
Could there be existential threats to humanity due to AI?
We are doing research, spending hours figuring out how we can make real AI software (intelligent agents) to work better. We are also trying to implement some applications e.g. in business, health and education, using the AI technology.
Nonetheless, so far, most of us have ignored the "dark" side of artificial intelligence. For instance, an "unethical" person could buy thousands of cheap drones, arm them with guns, and send them out firing on the public. This would be an "unethical" application of AI.
Could there be (in the future) existential threats to humanity due to AI?

Any technology has the potential to be existential threat to humanity.

I would define intelligence as a ability to predict future. So if someone is intelligent, he can predict some aspects of future, and decide what to do based on his predictions. So, if "intelligent" person decide to hurt other persons, he might be very effective at this (for example Hitler and his staff).
Artificial intelligence might be extremely effective at predicting some aspects of uncertain future. And this IMHO leads to two negative scenarios:

Someone programs it for hurting people. Either by mistake or on purpose.
Artificial intelligence will be designed for doing something safe, but at some point, to be more effective, it will redesign itself and maybe it will remove obstacles from its way. So if humans become obstacles, they will be removed very quickly and in very effective way.

Of course, there are also positive scenarios, but you are not asking about them.
I recommend reading this cool post about artificial superintelligence and possible outcomes of creating it: http://waitbutwhy.com/2015/01/artificial-intelligence-revolution-1.html

There is no doubt that AI has the potential to pose an existential threat to humanity.

The greatest threat to mankind lies with superintelligent AI.

An artificial intelligence that surpasses human intelligence will be capable of exponentially increasing its own intelligence, resulting in an AI system that, to humans, will be completely unstoppable.
At this stage, if the artificial intelligence system decides that humanity is no longer useful, it could wipe us from the face of the earth.
As Eliezer Yudkowsky puts it in Artificial Intelligence as a Positive and Negative Factor in Global Risk,
"The AI does not hate you, nor does it love you, but you are made out of atoms which it can use for something else."

A different threat lies with the instruction of highly intelligent AI

Here it is useful to consider the paper clip maximiser thought experiment.
A highly intelligent AI instructed to maximise paper clip production might take the following steps to achieve its goal.
1) Achieve an intelligence explosion to make itself superintelligent (this will increase paperclip optimisation efficiency)
2) Wipe out mankind so that it cannot be disabled (that would minimise production and be inefficient)
3) Use Earth's resources (including the planet itself) to build self replicating robots hosting the AI
4) Exponentially spread out across the universe, harvesting planets and stars alike, turning them into materials to build paper clip factories

Clearly this is not what the human who's business paperclip production it was wanted, however it is the best way to fulfil the AI's instructions.

This illustrates how superintelligent and highly intelligent AI systems can be the greatest existential risk mankind may ever face.
Murray Shanahan, in The Technological Singularity, even proposed that AI may be the solution to the Fermi paradox: the reason why we see no intelligent life in the universe may be that once a civilisation becomes advanced enough, it will develop an AI that ultimately destroys it.
This is known as the idea of a cosmic filter.
In conclusion, the very intelligence that makes AI so useful also makes it extremely dangerous.
Influential figures like Elon Musk and Stephen Hawking have expressed concerns that superintelligent AI is the greatest threat we will ever have to face.
Hope that answers your question :)


text:
How can a system like Jarvis understand the commands and take actions?
I am looking to make an AI like Jarvis. A perfect real-life example of this type of system is the simple AI that Mark Zuckerberg has recently built. Here is a description of how his AI works. From what I understand, the AI understands keywords, context, synonyms, and then from there decides what to do. Here is also a video of the AI in action.
I have many questions about how these systems works. Firstly, what necessary steps are required to gather the meaning of a input? Secondly, how does the system, once it extracts all of the necessary information on the input, determine what action it needs to take and what to say back to the user? Lastly, it also states that the system can learn the habits and preferences of the user. How can a system do this?

Jarvis was built using the suite of tools that facebook developers are constantly updating. The answer to this question is that there's no simple answer; it has a lot of moving parts.
Take for example natural language processing. There are a number of sub-topics that are each considered "big" problems, such as part-of-speech recognition, coreference resolution, sentiment analysis, relationship extraction, and many more. Tools have been built to tackle these various topics, but, to my knowledge, none of them really understand language, but rather statistically approximate it.
In the case of Jarvis, since it is a home-automation system, it's probably built with the user-given commands in mind from the beginning, so it's not trying to understand the whole human language, it's built to do some tricks.
Just keep in mind on your journey into this space that true AI like what we imagine will have some defining features like hierarchical representations of tasks and goal-orientation. If you really get into it I'd start with reinforcement learning, or try reading through the Society of Minds.

The question was very general, so it's difficult to give a specific answer. However, although what you say about NLP and NLU seems to be valid, you should probably provide some reliable references that describe in detail one of these systems.


text:
What is the difference between a stacked restricted Boltzmann machine and deep belief network?
What is the difference between stacked restricted Boltzmann machine (RBM) and deep belief network (DBN)?
Are they the same entity? If so, why? Is the latter some specific type of the former? If so, how to tell if stacked RBM is a DBN?

For what it's worth, Wikipedia says that

deep belief networks can be formed by "stacking" RBMs.

Hinton writes in Scholarpedia:

A deep belief net can be viewed as a composition of simple learning modules each of which is a restricted type of Boltzmann machine.

So, a deep belief network is definitely a stacked RBM.
I have never heard of different stacked RBMs, but it is easy to imagine something like convolutional stacked RBMs, where some RBMs are used as filters that slide over the input data or something. Whether that would still be called a deep belief network, is probably up to the guy who publishes it first.

RBM is undirected. Shoud not DBN have directed units (umhh.. classifiers?) as top layers? Can be simple stacked RBM which is basically a feature detector, can be studied as a DBN?

What do you mean RBMs are undirected? They have an input layer and the input gets propagated to a hidden layer (and back during training). That looks pretty directed to me. I think BMs are undirected. If you want to do classification you'll put a classifier on top, that's correct.

By "undirected" i mean a possibility of input reconstruction from known feature vector (like with an autoencoder), which is not so straightforward for classifiers. Anyway, things became a bit clearer. Thank you:)

The possibility of input reconstruction from the hidden layer activation is how you train, but once you've learned your features the backward pass isn't used anymore. So then you just have an ordinary feedforward network.


text:
How do I design a neural network that breaks a 5-letter word into its corresponding syllables?
I am going to design a neural network which will be able to break a 5-letter word into its corresponding syllables (hybrid syllables, I mean it will not strictly adhere to grammatical syllable rules but will be based on some training sets I provide).
Example: "train" -> "tra"-"in".
I think of implementing it in terms of some feedforward neural network with 1 input layer, 1 hidden layer and 1 output layer.
There will be 5 input nodes in the form of decimals (1/26 = 0.038 for 'A' ; 2/26 = 0.076 for 'B', etc.)
The output layer consists of 4 nodes, which corresponds to each gap between two characters in the word.
And fires as follows:

For "train" ("tra"-"in"), the input is (0.769, 0.692, 0.038, 0.346, 0.538) and the output would be (0, 0, 1, 0).

For "boric" ("bo"-"ri"-"c"), the input is something else, and the output is (0, 1, 0, 1).

Is it possible to implement the neural network in the way I am doing? If possible, then how will I decide the number of hidden layers and nodes in each layer?
In the book I am reading, the XOR gate problem and its implementation using hidden layer is given. In XOR, we could decide the number of nodes and hidden layers required by seeing the linear separability of XOR using two lines. But here I think such analysis can't be made..
So, how do I proceed? Or is it a trial and error process?

I would highly recommend modeling things differently with regard to how letters are presented to the model. While the problem is more natural, perhaps, for a Convolutional or Recurrent Neural Network, there's no problem to try and run this on a feed forward network. However, the way you give letters as input will be very confusing for a network and will make learning very hard. I'd recommend using one hot encoding or even a binary encoding for the letters. If this is for more than playing around I'd try and add some info (encode whether the letter is in "aeiou" in a separate bit).
As for the hidden layers, try playing around a bit. Two systematic approaches are to start very simple and make the model more complicated, or start complicated and make your model simpler (or just normalize a lot). Look at the performance on the training set and on a separate validation set during training. If the model keeps on improving on the training data but starts to deteriorate on the validation data, you're probably over fitting. In this case you should either make the model simpler (fewer nodes, fewer layers) or regularize (start with l2 normalization on the weights). If the data doesn't perform well on the training data, you may wish to make the model more complex.
Once you've tried the feedforward network, really do try CNN or RNNs for this task.


text:
What kind of algorithm is used by StackGAN to generate realistic images from text?
What kind of algorithm is used by StackGAN to generate realistic images from text? How does StackGAN work?

The paper StackGAN: Text to Photo-realistic Image Synthesis
with Stacked Generative Adversarial Networks should provide the answers to your questions.
Here's an excerpt from the abstract of the paper.

Synthesizing photo-realistic images from text descriptions is a challenging problem in computer vision and has many practical applications. Samples generated by existing text-to-image approaches can roughly reflect the meaning of the given descriptions, but they fail to contain necessary details and vivid object parts. In this paper, we propose stacked Generative Adversarial Networks (StackGAN) to generate photo-realistic images conditioned on text descriptions. The Stage-I GAN sketches the primitive shape and basic colors of the object based on the given text description, yielding Stage-I low resolution images. The
Stage-II GAN takes Stage-I results and text descriptions as inputs, and generates high resolution images with photorealistic details. The Stage-II GAN is able to rectify defects and add compelling details with the refinement process.


text:
Are ReLUs incapable of solving certain problems?
Background
I've been interested in and reading about neural networks for several years, but I haven't gotten around to testing them out until recently.
Both for fun and to increase my understanding, I tried to write a class library from scratch in .Net. For tests, I've tried some simple functions, such as generating output identical to the input, working with the MNIST dataset, and a few binary functions (two input OR, AND and XOR, with two outputs: one for true, one for false).
Everything seemed fine when I used a sigmoid function as the activation function, but, after reading about the ReLUs, I decided to switch over for speed.
Problem
My current problem is that, when I switch to using ReLUs, I found that I was unable to train a network of any complexity (tested from as few as 2 internal nodes up to a mesh of 100x100 nodes) to correctly function as an XOR gate.
I see two possibilities here:

My implementation is faulty. (This one is frustrating, as I've re-written the code multiple times in various ways, and I still get the same result).

Aside from being faster or slower to train, there are some problems that are impossible to solve given a specific activation function. (Fascinating idea, but I've no idea if it's true or not).

My inclination is to think that 1) above is correct. However, given the amount of time I've invested, it would be nice if I could rule out 2) definitively before I spend even more time going over my implementation.
More details
For the XOR network, I have tried both using two inputs (0 for false, 1 for true), and using four inputs (each pair, one signals true and one false, per "bit" of input). I have also tried using 1 output (with a 1 (really, >0.9) corresponding to true and a 0 (or <0.1) corresponding to false), as well as two outputs (one signaling true and the other false).
Each training epoch, I run against a set of 4 inputs $\{ (00, 0), (01, 1), (10, 1), (11, 0) \}$.
I find that the first three converge towards the correct answer, but the final input (11) converges towards 1, even though I train it with an expected value of 0.

There are a variety of possible things that could be wrong, but let me give you some potentially useful information.
Neural networks with ReLU activation functions are Turing complete for a computation with on order as many steps as the network contains nodes - for a recurrent network (an RNN), that means the same level of turing completeness as any finite computer. In other words, for any function/algorithm that you want to compute, you can devise a neural network, potentially recurrent, that will approximate/compute it.
As an example, suppose that we want to compute the NOR function, which can be used to implement a Turing machine.  We can do it with the following neural network with a ReLU activation function.
Let the input be
$$ W = \begin{bmatrix}x_1 \ \ x_2 \end{bmatrix}$$
the weight matrix be
$$ W = \begin{bmatrix} -20 \\ -20 \end{bmatrix}$$
and the bias be
$$ b = \begin{bmatrix} 1 \end{bmatrix}$$
Then the ReLU unit (or neuron) performs the following operation
$$o = \max(Wx + b, 0)$$
So, $o = 1$ only when both $x_1$ and $x_2$ are $0$, otherwise, it's always $0$.
However, gradient descent is a finicky way to search for RNNs. There are a wide variety of ways that it might have been failing. In general, once you have very thoroughly checked your gradient, I'd make sure to use Adam as the optimizer and then play with the hyperparameters endlessly until I find an incantation that works.
For further reading on general understanding of this level of deep learning's capability limitations, I'd recommend this blog post by Ilya Sutskever, now an OpenAI researcher: http://yyue.blogspot.com/2015/01/a-brief-overview-of-deep-learning.html?m=1

While I have not determined if there are problems that cannot be solved with ReLU, I have found ample documentation in the literature that XOR is solvable with as few as 1 hidden node.
The solution is simpler than I thought. The output layer needs connections, not just to the intermediate layer, but directly to the input layer as well. This allows the network to train XOR effectively.
One final note, the XOR is extremely sensitive to the learning rate. Essentially, whatever learning rate is appropriate for the AND and OR functions, is approximately 1000x too large to train XOR effectively.

I tried to use 2 hidden ReLU-based unit, 1 output unit to solve the XOR problem and found that gradient will always become really small after training 1000 times.
The Loss vs training times:

And the gradient looks like:

I think that means the units all dead. The robust way to solve this problem is increase the number of units.
When it comes to 4 units, some times I will success, but sometimes not.
And 5 units, I will fail but the rate decrease.

And so on. That is all.
I will try to use sigmoid + cross entropy instead of ReLU, I imagine linear function will work better in this case.


text:
Which approaches could I use to create a simple chatbot using a neural network?
I wanted to start experimenting with neural networks, so I decided to make a chatbot (like Cleverbot, which is not that clever anyway) using them.
I looked around for some documentation and I found many tutorials on general tasks, but few on this specific topic. The one I found just exposed the results without giving insights on the implementation. The ones that did, did it pretty shallowly (the TensorFlow documentation page on seq2seq is lacking, IMHO).
Now, I feel I may have understood the principle more or less, but I'm not sure and I am not even sure how to start. Thus I will explain how I would tackle the problem and I'd like feedback on this solution, telling me where I'm mistaken, and possibly have any link to detailed explanations and practical knowledge on the process.

The dataset I will use for the task is the dump of all my Facebook and WhatsApp chat history. I don't know how big it will be but possibly still not large enough. The target language is not English, therefore I don't know where to quickly gather meaningful conversation samples.

I am going to generate a thought vector out of each sentence. Still don't know how, actually; I found a nice example for word2vec on the deeplearning4j website, but none for sentences. I understood how word vectors are built and why, but I could not find an exhaustive explanation for sentence vectors.

Using thought vectors as input and output I am going to train the neural network. I don't know how many layers it should have, and which ones have to be LSTM layers.

Then there should be another neural network that is able to transform a thought vector into a sequence of characters composing a sentence. I read that I should use padding to make up for different sentence lengths, but I miss how to encode characters (are codepoints enough?).

I would recommend to start by reading this blogpost.
You can probably cannibalise the code to create a RNN that takes in one statement of a dialogue and then proceeds to output the answer to that statement.
That would be the easy version of your project, all without word vectors and thought vectors. You are just inputting characters, so typos don't need to concern you.
The next more complex step would be to input word vectors instead of characters. That would allow you to generalise to words that aren't part of your training data. And it is probably still just a minor modification of the code.
If you insist on using thought vectors, you should start reading up on NN translation. And probably try to get a pre-trained encoder network. Or pre-train it yourself on a large translation corpus for your language.
With your small training set the best you can do is probably massively overfit until your system recreates your training data verbatim. Using word vectors will allow your system to give the same answer to "I beat the cat today." as you gave in the training data to "I kicked the dog yesterday."
I'm not sure thought vectors will make a big difference. If you get the decoder to learn at all.

I already read the first article some time ago and I feel characters are not the right level of abstraction. I didn't think about going with word vectors one at a time but I guess that is an interesting and less complex way too. I'll read the paper, which is probably what I was after...


text:
How to detect a full-fledged self-aware AI?
The premise: A full-fledged self-aware artificial intelligence may have come to exist in a distributed environment like the internet. The possible A.I. in question may be quite unwilling to reveal itself.
The question: Given a first initial suspicion, how would one go about to try and detect its presence? Are there any scientifically viable ways to probe for the presence of such an entity? In other words, how would the Turing police find out whether or not there's anything out there worth policing?

This question seems to be related to or a duplicate of this one.

To decide whether an AI was self-aware, I would ask it to answer questions about itself, and see if it gave correct answers to those questions.

@AndersonGreen I think that verbalizing self-awareness doesn't proof being actually aware. Similarly, verbalizing empathy does not imply its existence. Related question:  https://ai.stackexchange.com/questions/11927/will-we-be-able-to-build-an-artificial-intelligence-that-feels-empathy
But if the system has been given the task to know itself and has had the opportunity to first ask questions about itself to us human sensors, and has built a self-concept from that external coherent information... it can develop what can be labeled as artificial awareness, why not.

This question should probably be moved to worldbuilding.stackexchange …
That being said, in the context of a story, I would look at something like the neural correlates of consciousness. In this book by Stanislas Dehaene the experiments are described that led to the realisation that conscious perception requires information integration in certain parts of the prefrontal cortex. Basically the brain processes many different interpretations of a percept in parallel. To become conscious of the percept this interpretations have to be collapsed into a single "truth" which is propagated to a specific part of the brain.
In your story you could have a researcher of consciousness stumble upon a chart of information flow in a part of the internet and realise that the same kind of information integration is going on.

Thanks for pointing me to those resources! Seems to be what I was looking for: Potentially observable patterns to be expected where human-like intelligence forms or has formed. Concerning worldbuilding.stackexchange - I actually thought about posting there but after lenghty reading of other posts got the impression that a lot of the more tech or science specific questions end up being moved to the respective science sites. So I tried my luck here. But I'd be glad to be moved over, if it seems more fitting.

"A full-fledged self-aware artificial intelligence may have come to exist in a distributed environment like the internet"

The question implies that this artificial intelligence has surpassed human intelligence (full fledged) and therefore, due to the concept of the intelligence explosion resulting from such a state, the AI you are looking for is no doubt superintelligent.

The question states that this AI is

"unwilling to reveal itself"

and therefore does not intend to be discovered.

Strong (or Superintelligent) AI

Given these two factors (its superior intellect and its unwillingness to be discovered), we can conclude that there is no way in which we would be able to detect such an AI under conventional conditions.

A possible solution may involve employing a second superintelligent AI system, but this is precarious in more ways than one.

Weak AI

Detection of a simpler AI would rely on tracking the pattern of activity and the traces it leaves behind in this distributed network in order to find it, then subjecting it to some form of testing to verify its intelligence.

There are a very large number of possible indicators and these would vary widely depending on the specific AI concerned. This would depend especially on how the AI exists within the framework (here, the web).
Note: a superintelligent AI would not only be able to disguise its activity, but also find a way around any test we can develop - these abilities are what renders this level of AI perhaps the greatest threat to mankind, but also our greatest asset if we do develop it and find a way to gain its alliance.

Comments are not for extended discussion; this conversation has been moved to chat.


text:
Could an AI be killed in an infinite loop?
Currently, we use control flow statements (such as loops) to program the artificially intelligent systems. Could an AI be killed in an infinite loop (created by itself, for example, while manipulating its source code)?
The question isn't baseless, it really questions the kind of computational infrastructure a modern AGI would require, and would it be able to alter itself without any intervention.

This is a hard to answer question because a truly correct answer would involve static analysis of a given Intelligence to determine whether it has the computational capability to generate a looping state (e.g. some state which reproduces itself in the next instance), and in fact whether these looping states can even exist in the given architecture.
Generally speaking, assuming we can build AI, there is no reason it would be impossible build an AI that has the potential to get stuck in a computational loop and become non-functional. You can imagine a recurrent neural network where the continuous state inside the ANN dominates its behavior causing it to reproduce states with small variety (as input will always be relevant in a connected ANN) but are converged around a particular state space. Whether that is akin to death is a philosophical question for your own peace of mind.
However, if we designed an AI agent that commonly did this, that would reflect poor design; that wouldn't necessarily devalue the contribution of the designed agent but it would bring the agent's other activities under scrutiny. If this is a bi-product of some simulated intelligence, is the process going on really that intelligent?


text:
What will happen when you place a fake speedsign on a highway?
I was wondering what will happen when somebody places a fake speedsign, of 10 miles per hour on a high way. Will a autonomous car slow down? Is this a current issue of autonomous cars?

https://www.technologyreview.com/s/530276/hidden-obstacles-for-googles-self-driving-cars/

Google’s cars can detect and respond to stop signs that aren't on its map, a feature that was introduced to deal with temporary signs used at construction sites. But in a complex situation like at an unmapped four-way stop the car might fall back to slow, extra cautious driving to avoid making a mistake.

It's highly probable they would slow down with current technology, as they can detect temporary signs and are designed to use slow speed in complex cases.
If it was a true temporary sign (e.g. road repair), how can it make the distinction? It probably would be worse to ignore a slow down sign than slow down at a fake one.
IMHO, the problem there is with the joke in the first place, as some humans might slow down too.