text:
Are there any decentralized examples of AI systems with blockchain technology?
Has there been any attempts to deploy AI with blockchain technology?
Are there any decentralized examples of AI networks with no central point of control with AI nodes acting independently (but according to a codified set of rules) creating, validating and storing the same shared decentralized database in many locations around the world?

You can also read this article How Can Blockchain Make Artificial Intelligence Better?.

Swarm intelligence is the term for systems where relatively simple agents work together to solve a complicated problem in a decentralized fashion.
In general, distributed computing methods are very important for dealing with problems at scale, and many of them embrace decentralization in a deep way. (Given the reality of hardware failure and the massive size of modern datasets relative to individual nodes, the less work is passed through a central bottleneck, the better.)
While there are people interested in doing computation on the blockchain, it seems to me like it's unlikely to be competitive with computation in dedicated clusters (like AWS).

Because of the simplicity of the agents, swarm intelligence is often not very decentralized in the specific sense of being "I/O bound, rather than compute-bound". That is, the amount of computation that agents do in between communicating is quite small. This is true, for example, in swarm intelligence systems such as Ant Colony Optimization and Particle Swarm Optimization. A system with agents performing more computationally-intensive operations is perhaps more akin to a blackboard architecture...

This does not answer the question "Has there been any attempts to deploy AI with blockchain technology?". SI doesn't necessarily use blockchain. Yes, distributed computing is important, but this also doesn't answer the question related to blockchain (not just distributed computing).

I think the best example of AI being deployed on the blockchain is SingularityNET. They just had a successful token sell where they sold out of their AGI token which will be able to be used to essentially "pay" for AI tasks to be done for you. Various AI will be put on the network and able to interact and communicate with each other to get various tasks done. There are some great videos online where Dr. Ben Goertzel explains this further. And here is a link to their whitepaper.

Have a look at the paper Blockchain-Based Federated Learning in Medicine (2020), where the blockchain is used as a "federation" server for improving the parameters of local neural networks.

I'm aware of some works that use blockchains in federated learning scenario for accountability, incentivize participants and so on.
Here's an example, BlockFLA: Accountable Federated Learning via Hybrid Blockchain Architecture (2020), but there are probably many similar works around.

Maybe the term you're looking for is federated learning. Check out OpenMined project, PySyft and Tensorflow Federated libraries.

I'm currently working on a p2p framework to train with neuroevolution, it will have neat, hyperneat, and eshyperneat example experiments. AI developers will be able to fork and add any experiments they want.
It isn't a blockchain per sé but will have a dht for genes, champion nets, peers of course, and genomes. Neuroevolution training can be done in parallel so the population will be distributed evenly among peers, peers that finish early will help slower peers with their evaluations, and all peers will have a check on one of the nets they evaluated by a random peer to prevent malice and all peers will check the champion of each generation. Any peer that evaluates a net will be rewarded a token that is specific to the generation it helped train and will also download a copy of the champion net, later I plan to allow non training clients the ability to view performance of past champs and purchase them from the network, any peer with a token for the genome they purchase will receive part of the payment. This will not be proof of stake, it will be a proof of work where work is evaluating nets, since this needs to be checked by other nets so people don't just post phony fitness for genomes I'll be calling it proof of fitness.


text:
How powerful a computer is required to simulate the human brain?
How much processing power is needed to emulate the human brain? More specifically, the neural simulation, such as communication between the neurons and processing certain data in real-time.
I understand that this may be a bit of speculation and it's not possible to be accurate, but I'm sure there is some data available or research studies that attempted to estimate it based on our current understanding of the human brain.

H+ magazine wrote an estimate in 2009 that seems broadly comparable to other things I've seen; they think the human brain is approximately 37 petaflops. A supercomputer larger than that 37 petaflop estimate exists today.
But emulation is hard. See this SO question about hardware emulation or this article on emulating the SNES, in which they require 140 times the processing power of the SNES chip to get it right. This 2013 article claims that a second of human brain activity took 40 minutes to emulate on a 10 petaflop computer (a 2400-times slowdown, not the 4-times slowdown one might naively expect).
And all this assumes that neurons are relatively simple objects! It could be that the amount of math we have to do to model a single neuron is actually much more than the flops estimate above. Or it could be the case that dramatic simplifications can be made, and if we knew what the brain was actually trying to accomplish we could do it much more cleanly and simply. (One advantage that ANNs have, for example, is that they are doing computations with much more precision than we expect biological neurons to have. But this means emulation is harder, not easier, while replacement is easier.)

The human brain contains about 100 billion neurons ($10^{11}$) and about a hundred trillion synapses ($10^{14}$). Each neuron can fire about 100 times a second. If we model the brain as a simple neural network, then it would be equivalent to a machine that requires 1016 calculations per second and 1013 bits of memory.
From Wikipedia

Kurzweil introduces the idea of "uploading" a specific brain with every mental process intact, to be instantiated on a "suitably powerful computational substrate". He writes that general modeling requires 1016 calculations per second and 1013 bits of memory, but then explains uploading requires additional detail, perhaps as many as 1019 cps and 1018 bits. Kurzweil says the technology to do this will be available by 2040.

According to this site here:

Using the NEST software framework, the team led by Markus Diesmann and Abigail Morrison succeeded in creating an artificial neural network of 1.73 billion nerve cells connected by 10.4 trillion synapses. While impressive, this is only a fraction of the neurons every human brain contains. Scientists believe we all carry 80-100 billion nerve cells
It took 40 minutes with the combined muscle of 82,944 processors in K computer to get just 1 second of biological brain processing time. While running, the simulation ate up about 1PB of system memory as each synapse was modeled individually.

Computing power will continue to ramp up while transistors scale down, which could make true neural simulations possible in real-time with supercomputers.
SpiNNaker is a manycore computer architecture designed to simulate the human brain. It is planned to use 1 million ARM processors (currently .5 million). The completed design will hold 100,000 cores
In this video, they showed a completed rack with 100,000 cores emulating 25 million neurons (at $\frac{1}{4}$ the efficiency—it will eventually run 1,000 neurons per core).

This concept is a bit brute-force... I'm a bioneurocybernetics specialist and I can tell you the thing that the classical - in terms of general IT - simulation or emulation of brain is impossible due to the structure of brain-body "interfaces".

Ik even the SpiNNaker the final design would only be able to simulate just 1% of the brain (also we still need to understand a lot about human brain)

"1013 bits of memory"? How did you arrive at that?

Not just how much, but what kind of processing power : there're specially-crafted dedicated chips, and it has a practical applications, so it's not a lab-only project

source: Stack Exchange

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

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

sort: votes


text:
What research has been done in the domain of "identifying sarcasm in text"?
Identifying sarcasm is considered one of the most difficult open-ended problems in the domain of ML and NLP/NLU.
So, was there any considerable research done on that front? If yes, then what is the accuracy like? Please, also, explain the NLP model briefly.

http://www.popsci.com/technology/article/2010-05/computer-algorithm-can-recognize-sarcasm-which-soooo-cool

The following survey article by researchers from IIT Bombay summarizes recent advances in sarcasm detection: Arxiv link.
In reference to your question, I do not think it is considered either extraordinarily difficult or open-ended. While it does introduce ambiguity that computers cannot yet handle, Humans are easily able to understand sarcasm, and are thus able to label datasets for sarcasm detection.

There has been a recent work in the same domain where neural networks(CNNs to be accurate) are used for the same purpose. Some info. about the research is:

To learn that context, the paper describes a method by which the
  neural network finds the user’s “embeddings” — i.e. contextual cues
  like the content of previous tweets, related interests and accounts,
  and so on. It uses these various factors to plot the user with others,
  and (ideally) finds that they form relatively well-defined groups.

So, the paper uses CNNs, word and user embeddings for detecting sarcasm in text. There is also a Techcrunch article on that.
The paper uses sentiment of the tweet and compares with that of the other similar tweets:

If the sentiment of the tweet seems to disagree with the bulk of what
  is expressed by similar users, there’s a good chance sarcasm is being
  employed.

Link to the paper

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


text:
Are Asimov's Laws flawed by design, or are they feasible in practice?
Isaac Asimov's famous Three Laws of Robotics originated in the context of Asimov's science fiction stories. In those stories, the three laws serve as a safety measure, in order to avoid untimely or manipulated situations from exploding in havoc.
More often than not, Asimov's narratives would find a way to break them, leading the writer to make several modifications to the laws themselves. For instance, in some of his stories, he modified the First Law, added a Fourth (or Zeroth) Law, or even removed all Laws altogether.
However, it is easy to argue that, in popular culture, and even in the field of AI research itself, the Laws of Robotics are taken quite seriously. Ignoring the side problem of the different, subjective, and mutually-exclusive interpretations of the laws, are there any arguments proving the laws themselves intrinsically flawed by their design, or, alternatively, strong enough for use in reality? Likewise, has a better, stricter security heuristics set being designed for the purpose?

Beware the Killbot Hellscape! https://xkcd.com/1613/

We musn't forget this possibility: http://www.xkcd.com/1450/

Asimov's laws are just a small attempt at starting the discussion. For a much more thorough discussion, read "Superintelligence" by Nick Bostrom - that's as exhaustive as it gets based on current knowledge and understanding.

Asimov's laws are not strong enough to be used in practice. Strength isn't even a consideration, when considering that since they're written in English words would first have to be interpreted subjectively to have any meaning at all. You can find a good discussion of this here.
To transcribe an excerpt:

How do you define these things? How do you define "human", without first having to take a stand on almost every issue. And if "human" wasn't hard enough, you then have to define "harm", and you've got the same problem again. Almost any really solid unambiguous definitions you give for those words—that don't rely on human intuition—result in weird quirks of philosophy, leading to your AI doing something you really don't want it to do.

One can easily imagine that Asimov was smart enough to know this and was more interested in story-writing than designing real-world AI control protocols.
In the novel Neuromancer, it was suggested that AIs could possibly serve as checks against each other. Ray Kurzweil's impending Singularity, or the possibility of hyperintelligent AGIs otherwise, might not leave much of a possibility for humans to control AIs at all, leaving peer-regulation as the only feasible possibility.
It's worth noting that Eliezer Yudkowsky and others ran an experiment wherein Yudkowsky played the role of a superintelligent AI with the ability to speak, but no other connection outside of a locked box. The challengers were tasked simply with keeping the AI in the box at all costs. Yudkowsky escaped both times.

Do you know if any transcript of the Yudkowsky experiments were ever released? The link you give (and the email exchange it then links to) doesn't appear to provide one.

@user217281728 No, I looked for it but it appears he's keeping it, i.e. his strategy under wraps to maintain the possibility of doing it again. I have some ideas about what he said and why I think that, that I'd be happy to share if you DM me.

I've now done this.

I'm under the impression that Asimov was smart enough to know this, but the point was that simple rules don't work. Pointing out negative examples ("you can't just tell it to not harm people, that won't work") is useful real-world AI control work in its own right.

Asimov made the three laws specifically to prove that no three laws are sufficient, no matter how reasonable they seem at first. I know a guy that knew the guy and he confirmed this.

"I know a guy who knew the guy"... Don't you have a slightly more reliable source? I'm not doubting your answer, but there should surely already exist a proper quote on the matter.

His name was Ben Williams. This is the Google Plus post where he described his opinions about Asimov and the Three Laws: https://plus.google.com/+JohnNewmanIII/posts/HeTnPdhaY9p

Consider Asimov's first law of robotics:

A robot may not injure a human being or, through inaction, allow a
  human being to come to harm.

That law is already problematic, when taking into consideration self-driving cars.
What's the issue here, you ask? Well, you'll probably be familiar with the classic thought experiment in ethic known as the trolley problem. The general form of the problem is this:

The trolley is headed straight for them. You are standing some
  distance off in the train yard, next to a lever. If you pull this
  lever, the trolley will switch to a different set of tracks. However,
  you notice that there is one person on the side track. You have two
  options: (1) Do nothing, and the trolley kills the five people on the
  main track. (2) Pull the lever, diverting the trolley onto the side
  track where it will kill one person. Which is the correct choice?
source : Wikipedia

Self-driving cars will actually need to implement real life variations on the trolley problem, which basically means that self-driving cars need to be programmed to kill human beings.
Of course that doesn't mean that ALL robots will need to be programmed to kill, but self-driving cars are a good example of a type of robot that will.

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


text:
How can the emotional quotient of an AI program be measured?
Can an AI program have an EQ (emotional intelligence or emotional quotient)?
In other words, can the EQ of an AI program be measured?
If EQ is more problematic to measure than IQ (at least with a standard applicable to both humans and AI programs), why is that the case?

What 'EQ tests' do you know of for humans? What would be the obstacle to applying them to an AI?

The answer to your question is "In principle, yes" - in it's most general form, EQ testing is just a specific case of the Turing test ("How would you feel about ... ?").
To see why meaningful EQ tests might be difficult to achieve, consider the following two possible tests:
At one extreme of complexity, the film 'Blade Runner' famously shows a test to distinguish between human and android on the basis of responses to emotionally-charged questions.
If you tried asking these questions (or even much simpler ones) to a modern chatbot, you'd likely quickly conclude that you were not talking to a person.
The problem with assessing EQ is that the more emotionally sophisticated the test, the more general the AI system is likely have to be, in order to turn the input into a meaningful representation.
At the other extreme from the above, suppose that an EQ test was phrased in an extremely structured way, with the structured input provided by a human. In such a case, success at an 'EQ test' is not really grounded in the real-world.
In an essay entitled "The ineradicable Eliza effect and its dangers", Douglas Hofstadter gives the following example, in which the ACME program is claimed (not by Hofstadter) to 'understand' analogy.

Here the computer learns about a fellow named Sluggo taking his wife Jane and
  his good buddy Buck to a bar, where things take their natural course and Jane
  winds up pregnant by Buck. She has the baby but doesn't want it, and so, aided
  by her husband, she drowns the baby in a river, thus "neatly solving "the problem"
  of Bambi.

This story is presented to ACME in the following form:
ql: (neglectful-husband (Sluggo))
q2: (lonely-and-sex-starved-wife (Jane-Doe))
q3: (macho-ladykiller (Buck-Stag))
q4: (poor-innocent-little-fetus (Bambi))
q5: (takes-out-to-local-bar (Sluggo Jane-Doe Buck-Stag))
...
q11: (neatly-solves-the-problem-of (Jane-Doe Bambi))
q12: (cause (ql0 q11))

Suppose the program were to be asked if Jane Doe's behavior was moral. Complex compound emotional concepts such as 'neglectful', 'lonely' and 'innocent' are here simply predicates, not available to the AI for deeper introspective examination. They could just as easily be replaced by labels such as as 'bling-blang-blong15657'.
So in one sense, the absence of success at an EQ test with any depth is indicative of the general problem currently facing AI: the inability to define (or otherwise learn) meaningful representations of subtle complexities of the human world, which is a lot more complex than being able to recognize videos of cats.


text:
How does "Monte-Carlo search" work?
I have heard about this concept in a Reddit post about AlphaGo. I have tried to go through the paper and the article, but could not really make sense of the algorithm.
So, can someone give an easy-to-understand explanation of how the Monte-Carlo search algorithm work and how is it being used in building game-playing AI bots?

A nice description of the MCTS algorithm can be found at: https://towardsdatascience.com/monte-carlo-tree-search-in-reinforcement-learning-b97d3e743d0f.

It is Monte Carlo tree search instead of just Monte Carlo search. MCS is more general and assumes less structure.

Monte Carlo method is an approach where you generate a large number of random values or simulations and form some sort of conlusions based on the general patterns, such as the means and variances.
As an example, you could use it for weather forecasts. Predicting long-term weather is quite difficult, because it is a chaotic system where small changes can lead to very different results. Using Monte Carlo methods, you could run a large number of simulations, each with slightly different atmospheric changes. Then you can analyze the results and for example calculate the probability of rain on a given day based on how many simulations ended up with rain.
As for the use of Monte Carlo in Alpha Go, they seem to be using the so-called Monte Carlo Tree Search. In this approach, you make a tree of possible moves, a few turns into the future, and try to find the best sequence. However, since the number of possible moves in the game of go is very large, you won't be able to explore very far ahead. This means that some of the moves which look good now might turn out to be bad later.
So, in the Monte Carlo Tree Search, you pick a promising sequence of moves and run one or more simulations of how the game might proceed from that point. Then you can use the results of that simulation to get a better idea of how good that specific sequence of moves really is and you update the tree accordingly. Repeat as needed until you find a good move.
If you want more information or to look at some illustrations, I found an interesting paper on the topic: C. Browne et al., A Survey of Monte Carlo Tree Search Methods (open repository / permanent link (paywalled))

So basically what monte carlo does in alphago is to create long term strategies , by considering different move combinations , instead of the other way around ( pick an strategy and then the moves to achieve it ) ?


text:
How to avoid falling into the "local minima" trap?
How do I avoid my gradient descent algorithm into falling into the "local minima" trap while backpropogating on my neural network?
Are there any methods which help me avoid it?

There are several elementary techniques to try and move a search out of the basin of attraction of local optima. They include:

Probabalistically accepting worse solutions in the hope that this
will jump out of the current basin (like Metropolis-Hastings acceptance in Simulated Annealing).
Maintaining a list of recently-encountered states (or attributes thereof) and not returning
to a recently-encountered one (like Tabu Search).
Performing a random walk of a length determined by the current state of the search (an explicit 'Diversification strategy', e.g. as used in 'Reactive Tabu Search').

See the excellent (and free online) book 'Essentials of Metaheuristics' by Sean Luke for more details on these kind of techniques and some rules of thumb about when and how to use them.


text:
What exactly are genetic algorithms and what sort of problems are they good for?
I've noticed that a few questions on this site mention genetic algorithms and it made me realize that I don't really know much about those.
I have heard the term before, but it's not something I've ever used, so I don't have much idea about how they work and what they are good for. All I know is that they involve some sort of evolution and randomly changing values.
Can you give me a short explanation, preferably including some sort of practical example that illustrates the basic principles?

Note that some of the answers below use the term "genetic algorithms" (GA) to refer to other types of evolutionary algorithms (EA), such as neuroevolution (e.g. this answer), which are not actually GA, which are thus a specific type of EA (where chromosomes are binary vectors). This "mistake" of using GA to refer to any EA is commonly done, but you should be aware of it.

Evolutionary algorithms are a family of optimization algorithms based on the principle of Darwinian natural selection. As part of natural selection, a given environment has a population of individuals that compete for survival and reproduction. The ability of each individual to achieve these goals determines their chance to have children, in other words, to pass on their genes to the next generation of individuals, who, for genetic reasons, will have an increased chance of doing well, even better, in realizing these two objectives.
This principle of continuous improvement over the generations is taken by evolutionary algorithms to optimize solutions to a problem. In the initial generation, a population composed of different individuals is generated randomly or by other methods. An individual is a solution to the problem, more or less good: the quality of the individual in regards to the problem is called fitness, which reflects the adequacy of the solution to the problem to be solved. The higher the fitness of an individual, the higher it is likely to pass some or all of its genotype to the individuals of the next generation.
An individual is coded as a genotype, which can have any shape, such as a bit vector (genetic algorithms) or a vector of real (evolution strategies). Each genotype is transformed into a phenotype when assessing the individual, i.e. when its fitness is calculated. In some cases, the phenotype is identical to the genotype: it is called direct coding. Otherwise, the coding is called indirect. For example, suppose you want to optimize the size of a rectangular parallelepiped defined by its length, height and width. To simplify the example, assume that these three quantities are integers between 0 and 15. We can then describe each of them using a 4-bit binary number. An example of a potential solution may be to genotype 0001 0111 1010. The corresponding phenotype is a parallelepiped of length 1, height 7 and width 10.
During the transition from the old to the new generation, the variation operators, whose purpose is to manipulate individuals, are applied. There are two distinct types of variation operators:

the mutation operators, which are used to introduce variations within the same individual, as genetic mutations;
the crossover operators, which are used to cross at least two different genotypes, as genetic crosses from breeding.

Evolutionary algorithms have proven themselves in various fields such as operations research, robotics, biology, nuance, or cryptography. In addition, they can optimize multiple objectives simultaneously and can be used as black boxes because they do not assume any properties in the mathematical model to optimize. Their only real limitation is the computational complexity.

A genetic algorithm is an algorithm that randomly generates a number of attempted solutions for a problem. This set of attempted solutions is called the "population".
It then tries to see how well these solutions solve the problem, using a given fitness function. The attempted solutions with the best fitness value are used to generate a new population. This can be done by making small changes to the attempted solutions (mutation) or by combining existing attempted solutions (crossover).
The idea is that, over time, an attempted solution emerges that has a high enough fitness value to solve the problem.
The inspiration for this came from the theory of evolution; the fittest solutions survive and procreate.
Example 1
Suppose you were looking for the most efficient way to cut a number of shapes out of a piece of wood. You want to waste as little wood as possible.
Your attempted solutions would be random arrangements of these shapes on your piece of wood. Fitness would be determined by how little wood would be left after cutting the shapes following this arrangement.
The less wood is left, the better the attempted solution.
Example 2
Suppose you were trying to find a polynomial that passes through a number of points. Your attempted solutions would be random polynomials.
To determine the fitness of these polynomials, you determine how well they fit the given points. (In this particular case, you would probably use the least squares method to determine how well the polynomial fit the points).
Over a number of trials, you would get polynomials that fit the points better, until you had a polynomial that fit the points closely enough.

What is meant by solution, though? Can you give me a practical example with a specific problem, so I can better imagine what it might look like?

@InquisitiveLurker I've added examples. Let me know if they aren't clear enough; I'll be glad to update my answer.

This answer requests a practical example of how one might be used, which I will attempt to provide in addition to the other answers. They seem to due a very good job of explaining what a genetic algorithm is. So, this will give an example.
Let's say you have a neural network (although they are not the only application of it), which, from some given inputs, will yield some outputs. A genetic algorithm can create a population of these, and by seeing which output is the best, breed and kill off members of the population. Eventually, this should optimise the neural network if it is complicated enough.
Here is a demonstration I've made, which despite being badly coded, might help you understand. http://khrabanas.github.io/projects/evo/evo.html
Hit the evolve button and mess around with the goals.
It uses a simple genetic algorithm to breed, mutate, and decide which individuals of the population survive. Depending on how the input variables are set, the network will be able to get to some level of closeness to them. In this fashion, the population will likely eventually become a homogeneous group, whose outputs resemble the goals.
The genetic algorithm is trying to create a "neural network" of sorts, that by taking in RGB, will yield an output color. First, it generates a random population. It then by taking 3 random members from the population, selecting the one with the lowest fitness and removing it from the population. The fitness is equal to the difference in the top goal squared + the difference in the bottom goal squared. It then breeds the two remaining ones together and adds the child to the same place in the population as the dead member. When mating occurs, there is a chance a mutation will occur. This mutation will change one of the values randomly.
As a side note, due to how it is set up, it is impossible for it to be totally correct in many cases, though it will reach relative closeness.

There are a number of good answers here explaining what genetic algorithms are, and giving example applications. I'm adding some general purpose advice on what they are good for, but also cases where you should NOT use them.
If my tone seems harsh, it is because using GAs in any of the cases in the inappropriate section below will lead to your paper being instantly rejected from any top-tier journal.
First, your problem MUST be an optimization problem. You need to define a "fitness function" that you are trying to optimize and you need to have a way to measure it.
Good

Crossover functions are easy to define and natural: When dealing with certain kinds of data, crossover/mutation functions might be easy to define. For example strings (eg. DNA or gene sequences) can be mutated easily by splicing two candidate strings to obtain a new one (this is why nature uses genetic algorithms!). Trees (like phylogenetic trees or parse trees) can be spliced too, by replacing a branch of one tree with a branch from another. Shapes (like airplane wings or boat shapes) can be mutated easily by drawing a grid on the shape and combining different grid sections from the parents to obtain a child. Usually this means your problem is composed of different parts and putting together parts from distinct solutions is a valid candidate solution.
This means that if your problem is defined in a vector space where the coordinates don't have any special meaning, GAs are not a good choice. If it is hard to formulate your problem as a GA, it is not worth it.
Black Box evaluation: If for a candidate, your fitness function is evaluated outside the computer, GAs are a good idea. For example, if you are testing a wing shape in an air tunnel, genetic algorithms will help you generate good candidate shapes to try.
Exception: Simulations. If your fitness function is measuring how well a nozzle design performs and requires simulating the fluid dynamics for each nozzle shape, GAs may work well for you. They may also work if you are simulating a physical system through time and are interested in how well your design performs over the course of the operation eg. modelling locomotion patterns. However, methods that use partial differential equations as constraints are being developed in the literature, eg. PDE constrained optimization, so this may change in the future.

Inappropriate

You can calculate a gradient for your function: If you have access to the gradient of your function, you can do gradient descent, which is in general much more efficient than GAs. Gradient descent may have issues with local minima (as will GAs) but many methods have been studied to mitigate this.
You know the fitness function in closed form: Then, you can probably calculate the gradient. Many languages have libraries supporting automatic differentiation, so you don't even need to do it manually. If your function is not differentiable, then you can use subgradient descent.
Your optimization problem is of a known form, like a linear program or a quadratic program: GAs (and black box optimization methods in general) are very inefficient in terms of the number of candidates they need to evaluate, and are best avoided if possible.
Your solution space is small: If you can grid your search space efficiently, you can guarantee that you have found the best solution, and can make contour plots of the solution space to see if there is a region you need to explore further.

Finally, if you are considering a GA, consider more recent work in Evolutionary Strategies. I am biased towards CMA-ES, which I think is a good simple algorithm that captures the notion of a gradient in the fitness landscape in a way that traditional GAs do not.

CMA-ES is good for problems in which the solutions can be represented as real-valued vectors.

The claim "will lead to your paper being instantly rejected from any top-tier journal." is false. In fact, GA have been successfully used as an alternative to gradient-based approaches (i.e. in problems where gradient-based approaches are applicable). Take a look at this example. So, I suggest that you edit that sentence and actually don't make that claim at all, as it's generally wrong.

As observed in another answer, all you need to apply Genetic Algorithms (GAs) is to represent a potential solution to your problem in a form that is subject to crossover and mutation. Ideally, the fitness function will provide some kind of smooth feedback about the quality of a solution, rather than simply being a 'Needle in a Haystack'.
Here are some characteristics of problems that Genetic Algorithms (and indeed Metaheuristics in general) are good for:

NP-complete - The number of possible solutions to the problem is
exponential, but checking the fitness of a solution is relatively
cheap (technically, with time polynomial in the input size).
Black box - GAs work reasonably well even if you don't have a particularly
informed model of the problem to be solved. This means that these
approaches are also useful as a 'rapid prototyping' approach to
solving problems.

However, despite their widespread use for the purpose, note that GAs are actually not function optimizers - GA mechanisms tend not to explore 'outlying' regions of the search space in the hope of finding some distant high quality solution, but rather to cluster around more easily attainable peaks in the 'fitness landscape'.
More detail on the applicability of GAs is given in a famous early paper "What makes a problem hard for a Genetic Algorithm?"

Regarding your statement "GA mechanisms tend not to explore 'outlying' regions of the search space in the hope of finding some distant high quality solution", have you heard of concepts like "novelty search"? Apparently, yes, because you wrote an answer here. In any case, although I didn't read the paper you link to, it seems that you're stating that all individuals of a population will tend to be similar (i.e. converge to some local optimum)? This may be possible, but it's not clear to me why you use the term "not function optimizers".

It’s not necessarily the case that the entire population converges to a single local optimum. The De Jong paper in the link describes the situation nicely.


text:
How is it possible that deep neural networks are so easily fooled?
The following page/study demonstrates that the deep neural networks are easily fooled by giving high confidence predictions for unrecognisable images, e.g.

How this is possible? Can you please explain ideally in plain English?

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

Related video: 'How neural networks learn' - Part II: Adversarial Examples.

First up, those images (even the first few) aren't complete trash despite being junk to humans; they're actually finely tuned with various advanced techniques, including another neural network.

The deep neural network is the pre-trained network modeled on AlexNet provided by Caffe. To evolve images, both the directly encoded and indirectly encoded images, we use the Sferes evolutionary framework. The entire code base to conduct the evolutionary experiments can be download [sic] here. The code for the images produced by gradient ascent is available here.

Images that are actually random junk were correctly recognized as nothing meaningful:

In response to an unrecognizable image, the networks could have output a low confidence for each of the 1000 classes, instead of an extremely high confidence value for one of the classes. In fact, they do just that for randomly generated images (e.g. those in generation 0 of the evolutionary run)

The original goal of the researchers was to use the neural networks to automatically generate images that look like the real things (by getting the recognizer's feedback and trying to change the image to get a more confident result), but they ended up creating the above art. Notice how even in the static-like images there are little splotches - usually near the center - which, it's fair to say, are triggering the recognition.

We were not trying to produce adversarial, unrecognizable images. Instead, we were trying to produce recognizable images, but these unrecognizable images emerged.

Evidently, these images had just the right distinguishing features to match what the AI looked for in pictures. The "paddle" image does have a paddle-like shape, the "bagel" is round and the right color, the "projector" image is a camera-lens-like thing, the "computer keyboard" is a bunch of rectangles (like the individual keys), and the "chainlink fence" legitimately looks like a chain-link fence to me.

Figure 8. Evolving images to match DNN classes produces a tremendous diversity of images. Shown are images selected to showcase diversity from 5 evolutionary runs. The diversity suggests that the images are non-random, but that instead evolutions producing [sic] discriminative features of each target class.

Further reading: the original paper (large PDF)

The problem is - How DNN gives such high confidence ~ 99% ! that these some-object-pattern-like pictures are representing true objects ? Unless DNN is mentally ill and thinks it takes Rorschach test in some hospital :-)

Sorry, I couldn't resist :-) "Bagel" is round, but so it is sun,eyeball,etc.
"Projector" could be an atom model, laser beam cross section, etc. And so on and so on. So why the hell, bagel is preferred over sun, projector is preferred over atom schema, etc. with 99% confidence ? For me - the main difference between DNN and human recognition is the fact that humans are not forced to recognize something, while NN seems are !

They were not forced to put it in 1 of a 1000 categories. They gave 99% confidence of 1 category.

The images that you provided may be unrecognizable for us. They are actually the images that we recognize but evolved using the Sferes evolutionary framework.
While these images are almost impossible for humans to label with anything but abstract arts, the Deep Neural Network will label them to be familiar objects with 99.99% confidence.
This result highlights differences between how DNNs and humans recognize objects. Images are either directly (or indirectly) encoded
According to this video

Changing an image originally correctly classified in a way imperceptible to humans can cause the cause DNN to classify it as something else.
In the image below the number at the bottom are the images are supposed to look like the digits
But the network believes the images at the top (the one like white noise) are real digits with 99.99% certainty.

The main reason why these are easily fooled is that Deep Neural Network does not see the world in the same way as human vision. We use the whole image to identify things while DNN depends on the features. As long as DNN detects certain features, it will classify the image as a familiar object it has been trained on.
The researchers proposed one way to prevent such fooling by adding the fooling images to the dataset in a new class and training DNN on the enlarged dataset. In the experiment, the confidence score decreases significantly for ImageNet AlexNet. It is not easy to fool the retrained DNN this time. But when the researchers applied such method to MNIST LeNet, evolution still produces many unrecognizable images with confidence scores of 99.99%.

More details here and here.

All answers here are great, but, for some reason, nothing has been said so far on why this effect should not surprise you. I'll fill the blank.
Let me start with one requirement that is absolutely essential for this to work: the attacker must know neural network architecture (number of layers, size of each layer, etc). Moreover, in all cases that I examined myself, the attacker knows the snapshot of the model that is used in production, i.e. all weights. In other words, the "source code" of the network isn't a secret.
You can't fool a neural network if you treat it like a black box. And you can't reuse the same fooling image for different networks.
In fact, you have to "train" the target network yourself, and here by training I mean to run forward and backprop passes, but specially crafted for another purpose.
Why is it working at all?
Now, here's the intuition. Images are very high dimensional: even the space of small 32x32 color images has 3 * 32 * 32 = 3072 dimensions. But the training data set is relatively small and contains real pictures, all of which have some structure and nice statistical properties (e.g. smoothness of color). So the training data set is located on a tiny manifold of this huge space of images.
The convolutional networks work extremely well on this manifold, but basically, know nothing about the rest of the space. The classification of the points outside of the manifold is just a linear extrapolation based on the points inside the manifold. No wonder that some particular points are extrapolated incorrectly. The attacker only needs a way to navigate to the closest of these points.
Example
Let me give you a concrete example how to fool a neural network. To make it compact, I'm going to use a very simple logistic regression network with one nonlinearity (sigmoid). It takes a 10-dimensional input x, computes a single number p=sigmoid(W.dot(x)), which is the probability of class 1 (versus class 0).

Suppose you know W=(-1, -1, 1, -1, 1, -1, 1, 1, -1, 1) and start with an input x=(2, -1, 3, -2, 2, 2, 1, -4, 5, 1). A forward pass gives sigmoid(W.dot(x))=0.0474 or 95% probability that x is class 0 example.

We'd like to find another example, y, which is very close to x but is classified by the network as 1. Note that x is 10-dimensional, so we have the freedom to nudge 10 values, which is a lot.
Since W[0]=-1 is negative, it's better for to have a small y[0] to make a total contribution of y[0]*W[0] small. Hence, let's make y[0]=x[0]-0.5=1.5.
Likewise, W[2]=1 is positive, so it's better to increase y[2] to make y[2]*W[2] bigger: y[2]=x[2]+0.5=3.5. And so on.

The result is y=(1.5, -1.5, 3.5, -2.5, 2.5, 1.5, 1.5, -3.5, 4.5, 1.5), and sigmoid(W.dot(y))=0.88. With this one change we improved the class 1 probability from 5% to 88%!
Generalization
If you look closely at the previous example, you'll notice that I knew exactly how to tweak x in order to move it to the target class, because I knew the network gradient. What I did was actually a backpropagation, but with respect to the data, instead of weights.
In general, the attacker starts with target distribution (0, 0, ..., 1, 0, ..., 0) (zero everywhere, except for the class it wants to achieve), backpropagates to the data and makes a tiny move in that direction. Network state is not updated.
Now it should be clear that it's a common feature of feed-forward networks that deal with a small data manifold, no matter how deep it is or the nature of data (image, audio, video or text).
Potection
The simplest way to prevent the system from being fooled is to use an ensemble of neural networks, i.e. a system that aggregates the votes of several networks on each request.
It's much more difficult to backpropagate with respect to several networks simultaneously. The attacker might try to do it sequentially, one network at a time, but the update for one network might easily mess up
with the results obtained for another network. The more networks are used, the more complex an attack becomes.
Another possibility is to smooth the input before passing it to the network.
Positive use of the same idea
You shouldn't think that backpropagation to the image has only negative applications. A very similar technique, called deconvolution, is used for visualization and better understanding what neurons have learned.
This technique allows synthesizing an image that causes a particular neuron to fire, basically see visually "what the neuron is looking for", which in general makes convolutional neural networks more interpretable.

Reading the paper it seems that the recognizer was treated as a black box.

If @GeorgeWhite is correct then this invalidates this otherwise great-looking answer. Do you have any comment on that?

An important question that does not yet have a satisfactory answer in neural network research is how DNNs come up with the predictions they offer. DNNs effectively work (though not exactly) by matching patches in the images to a "dictionary" of patches, one stored in each neuron (see the youtube cat paper). Thus, it may not have a high level view of the image since it only looks at patches, and images are usually downscaled to much lower resolution to obtain the results in current generation systems. Methods which look at how the components of the image interact may be able to avoid these problems.
Some questions to ask for this work are: How confident were the networks when they made these predictions? How much volume do such adversarial images occupy in the space of all images?
Some work I am aware of in this regard comes from Dhruv Batra and Devi Parikh's Lab at Virginia Tech who look into this for question answering systems: Analyzing the Behavior of Visual Question Answering Models and Interpreting Visual Question Answering models.
More such work is needed, and just as the human visual system does also get fooled by such "optical illusions", these problems may be unavoidable if we use DNNs, though AFAIK nothing is yet known either way, theoretically or empirically.

How is it possible that deep neural networks are so easily fooled?
Deep neural networks are easily fooled by giving high confidence predictions for unrecognizable images. How is this possible? Can you please explain ideally in plain English?

Intuitively, extra hidden layers ought to make the network able to learn more complex classification functions, and thus do a better job classifying. While it may be named deep learning it's actually a shallow understanding.
Test your own knowledge: Which animal in the grid below is a Felis silvestris catus, take your time and no cheating. Here's a hint: which is a domestic house cat?

For a better understanding checkout: "Adversarial Attack to Vulnerable Visualizations" and "Why are deep neural networks hard to train?".
The problem is analogous to aliasing, an effect that causes different signals to become indistinguishable (or aliases of one another) when sampled, and the stagecoach-wheel effect, where a spoked wheel appears to rotate differently from its true rotation.
The neural network doesn't know what it's looking at or which way it's going.
Deep neural networks aren't an expert on something, they are trained to decide mathematically that some goal has been met, if they are not trained to reject wrong answers they don't have a concept of what is wrong; they only know what is correct and what is not correct - wrong and "not correct" are not necessarily the same thing, neither is "correct" and true.
The neural network doesn't know right from wrong.
Just like most people wouldn't know a house cat if they saw one, two or more, or none. How many house cats in the above photo grid, none. Any accusations of including cute cat pictures is unfounded, those are all dangerous wild animals.
Here's another example. Does answering the question make Bart and Lisa smarter, does the person they are asking even know, are there unknown variables that can come into play?

We aren't there yet but neural networks can quickly provide an answer that is likely to be correct, especially if it was properly trained to avoid all misteps.

Can't comment(due to that required 50 rep), but I wanted to make a response to Vishnu JK and the OP. I think you guys are skipping the fact that the neural network only really is saying truly from a programmatic standpoint that "this is most like".
For example, while we can list the above image examples as "abstract art", they definitively are most like was is listed. Remember learning algorithms have a scope on what they recognize as an object and if you look at all the above examples... and think about the scope of the algorithum... these make sense (even the ones at a glance we would recognize as white noise). In Vishnu example of the numbers, if you fuzz your eyes and bring the images out of focus, you can actually in every case spot patterns that really closely reflect the numbers in question.
The problem that is being shown here is that the algorithm appears to not have a "unknown case". Basically when the pattern recognition says that it doesn't exist in the output scope. (so a final output node group that says this is nothing that I know off). For example, people do this as well, as it's one thing humans and learning algorithms have in common. Here's a link to show what I'm talking about (what is the following, define it) using only known animals that exist:

Now as a person, limited by what I know and can say, I'd have to conclude that the following is an elephant. But it's not. Learning algorithms (for the most part) do not have a "like a" statement, the out put always validates down to a confidence percentage. So tricking one in this fashion is not surprising... what is of course surprising is that based on it's knowledge set, it actually comes to the point in which, if you look at the above cases listed by OP and Vishnu that a person... with a little looking... can see how the learning algorithm probable made the association.
So, I wouldn't really call it a mislabel on the part of the algorithm, or even call it a case where it's been tricked... rather a case where it's scope was developed incorrectly.

You are forgetting the 99% confidence level the researchers found.

Indeed, an unknown image should be expected to return a low confidence level in every category. Is it a cat? No. Is it a dog? No. Is it a house? No. Is it a calculator? Sort of, it has all these buttons in a grid, but there's no screen and no writing on the buttons, so no.

The neural networks can be easily fooled or hacked by adding certain structured noise in image space (Szegedy 2013, Nguyen 2014) due to ignoring non-discriminative information in their input.
For example:

Learning to detect jaguars by matching the unique spots on their fur while ignoring the fact that they have four legs.2015

So basically the high confidence prediction in certain models exists due to a 'combination of their locally linear nature and high-dimensional input space'.2015
Published as a conference paper at ICLR 2015 (work by Dai) suggest that transferring discriminatively trained parameters to generative models, could be a great area for further improvements.

Neural networks are easily fooled, provided you know how to fool them.
Consider a linear network with an input layer and an output layer, which has an error function E (we don't need hidden layers to show how to fool a network). For a given input image x, E measures the (squared) difference between the network's output y and the desired (correct) output.
The output unit’s state y is given by the inner product of x with the output unit’s weight vector w,so that
y=w·x.

If we change x to x′ by adding ∆x then the output will change by ∆y to
y′ = w·x+w·∆x (9.4)

   = y + ∆y. (9.5)

Notice that ∆x defines a direction in the input space; the question is, which direction ∆x will have most impact on y?
By definition, a change in x in the direction ∇E produces the largest
possible change in y. An adversarial image x' is constructed by taking the derivative ∇E of E with respect to the input image x, that is,
   x′ = x + ε∇E,

where ε is a small constant.
By definition, ∇E is the direction of steepest ascent, so the modification ε∇E to x will alter y more than a change in any other direction.

This is an extract from the book: Artificial Intelligence Engines:  A Tutorial Introduction to the Mathematics of Deep Learning (2019).

There is already many good answers, I will just add to those that came before mine:
This type of images you are referring to are called adversarial perturbations, (see 1, and it is not limited to images, it has been shown to apply to text too, see Jia & Liang, EMNLP 2017. In text, the introduction of an irrelevant sentence which doesn't contradict the paragraph has been seen to cause the network to come to a completely different answer (see see Jia & Liang, EMNLP 2017).
The reason they work is due to the fact that neural network view images in a different way from us, coupled with the high dimentionality of the problem space. Where we see the whole picture, they see a combination of features which combine to form an object(Moosavi-Dezfooli et al., CVPR 2017). According to  perturbation generated against one network has been seen to have high likelihood to work on other networks:

In the figure above, it is seen that The universal perturbations computed for the VGG-19 network, for example, have a fooling ratio above 53% for all other tested architectures.
So how do you deal with the threat of adversarial perturbations?
Well, for one, you can try to generate as many perturbations as you can and use them to fine-tune your model. Whist this somewhat solves the problem, it doesn't solve the problem entirely. In (Moosavi-Dezfooli et al., CVPR 2017) the author reported that, repeating the process by computing new perturbations and then fine-tuning again seems to yield no further improvements, regardless of the number of iterations, with the fooling ratio hovering around 80%.
Perturbations are an indication of the shallow pattern matching that neural networks perform, coupled with their minimal lack of in-depth understanding of the problem at hand. More work still needs to be done.


text:
How to write a C decompiler using AI?
I would like to learn more about whether it is possible and how to write a program that decompiles executable binary (an object file) to the C source. I'm not asking exactly 'how', but rather how this can be achieved.
Given the following hello.c file (as example):
#include <stdio.h>
int main() {
  printf("Hello World!");
}

Then after compilation (gcc hello.c) I've got the binary file like:
$ hexdump -C a.out | head
00000000  cf fa ed fe 07 00 00 01  03 00 00 80 02 00 00 00  |................|
00000010  0f 00 00 00 b0 04 00 00  85 00 20 00 00 00 00 00  |.......... .....|
00000020  19 00 00 00 48 00 00 00  5f 5f 50 41 47 45 5a 45  |....H...__PAGEZE|
00000030  52 4f 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |RO..............|
00000040  00 00 00 00 01 00 00 00  00 00 00 00 00 00 00 00  |................|
00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000060  00 00 00 00 00 00 00 00  19 00 00 00 d8 01 00 00  |................|
00000070  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
$ wc -c hello.c a.out
  60 hello.c
8432 a.out

For the learning dataset, I assume I'll have to have thousands of source code files along with its binary representation, so the algorithm can learn about moving parts on certain changes.
How would you tackle this problem?
My concerns (and sub-questions) are:

Does my algorithm need to be aware of the header file, or it's "smart" enough to figure it out?

If it needs to know about the header, how do I tell my algorithm "here is the header file"?

What should be input/output mapping (whether some section to section or file to file)?

Do I need to divide my source code into some sections?

Do I need to know exactly how decompilers work or AI can figure it out for me?

Should I have two neural networks, one for header, another for body it-self?

or more separate neural networks, each one for each logical component (e.g. byte->C tag, etc.)

This is an old question, but it's not clear whether you want to solve this problem with deep learning or any AI technique. From the title, you say "using AI", but then in the body you focus on neural networks. So, please, edit your post to clarify this.

In-between your input and desired output, there's obviously a huge space to search. The more relevant domain information you include as features, the higher chance that the Deep Learning (DL) algorithm can find the desired mapping.
At this early stage in DL research, there aren't so many rules of thumb to tell you what features to explicitly encode - not least because it depends on the size of your training corpus. My suggestion would be: obtain (or generate) a large corpus of C code, train on that with the most naive feature representation that you think might work, then repeatedly gather data and add more feature preprocessing as necessary.
This following paper describes a DL approach to what is almost the 'reverse problem' to yours - generating the source code for a program described in natural language.
I found the strength of the results reported in this paper surprising, but it does give me some hope that what you are asking might be possible.

Software Reverse Engineering is one of my hobby.
First things first: forget about headers. All information about headers and separate C file is gone.
You're missing some crucial step, IMHO.

Compilation creates one or multiple object files (.o), then the linker creates an executable.

You should work from disassembled code. The disassembler works pretty well with some exceptions (self-modifying code, self-extracting executable, various obfuscation techniques) and will take care of a lot of work for you: identifying various sections, finding functions, guessing (fairly accurately) the calling convention.

Then the compiler optimization will mess up your code in a very clever way and some part of your original code will never ever be seen again (hey, look, your 200 lines of bugged code always return 0 anyway so I'll just replace them with "xor eax, eax").

Sometimes, it's fine, and sometimes it produces unreadable C code (vectorizations that have no C equivalent and will be decompiled into hundreds of lines of intrinsic instead of a fine readable "for" loop).

I'm not done yet. You also have exceptions and interrupts, structures, union, function pointers, function inlining, threading, system call and signals, loop unrolling, etc.

Going down (from human-readable to binary) is relatively easy compared to going up (decompilation) because so much information is lost during the compilation process.
My best bet would be to have a bunch of disassembled function produced by a disassembler and produce an LLVM intermediate representation using your AI, then compare it with the LLVM IR produced by Clang (clang -S -emit-llvm foo.c).
An infinite quantity of C code can produce the exact same code. Therefore, I think it's meaningless to make an AI read C code for the purpose of decompilation: the information is lost forever.
Commercial and Open/Free decompilers do not produce C code either, they produce some kind of pseudo-C full of errors, missing code, or code even less readable than the ASM.
The following code :
int main() {
    int toto = 0x0000BEEF;
    int titi = 0xDEAD0000;
    toto = toto | titi;
    return toto;
}

produces this:
int __cdecl main(int argc, const char **argv, const char **envp)
{
     return -559038737;
}

And this is the disassembled version:
mov     eax, 0DEADBEEFh
retn

Plus a few thousands lines of assembly that are unrelated to your code but are needed to make the program work.
You can't go back and you have no way of knowing this is the exact same code unless

you can do static analysis (very easy in this case, but absurdly difficult in the real world)

or compare the IR or ASM produced by both code with the same compiler with the same options on the same architecture and operating system.

Although they are pre-prints, maybe you should check these papers for more ideas: Towards Neural Decompilation and A Neural-based Program Decompiler. This paper Using Recurrent Neural Networks for Decompilation was actually published in IEEE/SANER. I didn't read them, but given that you're interested in the topic, you may want to read them. There's also the paper "C Decompilation : Is It Possible ?", but I couldn't find a free pdf online.

thank you. A quick look show that they are working with disassembled version and LLVM IR. Same as my suggestion, except that they think it can work :)  But we're already so so far away from the main concern of the OP about headers. I'll have to read more, the first paper you suggested seems easier to read than the others. I like how this is phrased : "Decompilation is a challenging task since the semantics in the high-level programming language (PL) is obliterated during compilation." :D


text:
How does an unsupervised learning model learn?
How does an unsupervised learning model learn, if it does not involve any target values?

Supervised learning is typically an attempt to learn a mathematical function, $f(\bf X)=\bf y$. For this, you need both the input vector $\bf X$ and the output vector $\bf y$. The model outputs have whatever dimensionality that the target values have.
Unsupervised learning models instead learn a structure from the data. A clustering model, for example, is learning both how many clusters exist in the data (a number that's not the same type as the inputs) and where those clusters are located (which is also a different type from the inputs). The output of running this model on a new datapoint $x$ is not the same type as $x$, but instead a classification label.
Similarly, time series models learn parameters that symbolize how vectors in the input relate to each other, rather than raw inputs themselves.
As for how they learn, the structures are mathematical objects whose fitness is determined by the input data. The simplest possible unstructured unsupervised learning problem is probably "what's the mean of the data?", and it should be clear how that's 'learned' through processing the input. More sophisticated models are just adding more pieces to that calculation.


text:
What are the approaches to predict sequence of $\pi$ numbers?
Given a list of fixed numbers from a mathematical constant, such as $\pi$, is it is possible to train AI to attempt to predict the next numbers of this constant?
Which AI or neural network would be more suitable for this task?
Especially, the one which will work without memorizing the entire training set, but the one which will attempt to find some patterns or statistical association.

That's going to depend on the PRNG algorithm. A good one would be completely unpredictable if you didn't know its state/seed.

I've narrowed down the question to Pi constant, I hope that helps.

As a mathematician, I really don't understand what your new question is/means. It is a well known conjecture that every string of (decimal) numbers/digtis appears infinitely many times in pi, so the next numbers could be anything. Also, there is a formula that allows us to calculate the nth (binary) digit of pi without knowing those before that, but finding the location of a string requires more since we can't use that formula backwards.

@wythagoras I mean that maybe ANN can detect some pattern where we humans can't.

Pseudo-random number generators are specifically defined to defeat any form of prediction via 'black box' observation. Certainly, some (e.g. linear congruential) have weaknesses, but you are unlikely to have any success in general in predicting the output of a modern RNG. For devices based on chaotic physical systems (e.g. most national lotteries), there is no realistic possibility of prediction.
"Patterns or statistical association" is a much weaker criterion than 'prediction'. Some very recent work has applied topological data analysis to visualize patterns within the infamous Randu RNG.

You would probably have to pack recursive structures into finite-dimensional real vectors and there have been such attempts. The finite precision limits goes as far as the recursion can go.
The limitation of feedforward neural networks is restricted to finite input and output spaces, so recurrent may be more suitable for this task as in theory can process arbitrarily long strings of numbers, but it has much more practical difficulties than feedforward network.
These kind of methods are open to debate.
Source: SAS FAQ
References:

Blair, 1997; Pollack, 1990; Chalmers, 1990; Chrisman, 1991; Plate, 1994; Hammerton, 1998; Hadley, 1999


text:
Are neural networks the only way to reach "true" artificial intelligence?
Currently, most research done in artificial intelligence focuses on neural networks, which have been successfully used to solve many problems.  A good example would be DeepMind's AlphaGo, which uses a convolutional neural network. There are many other examples, such as Google Translate, which uses transformers, or DQN, which has been used to play Atari games.
So, are any of the variants of neural networks the only way to reach "true" artificial intelligence (or AGI)?

If by true AI, you mean 'like human beings', the answer is - no-one knows what the appropriate computational mechanisms (neural or otherwise) are or indeed whether we are capable of constructing them.
What Artificial Neural Nets (ANNs) do is essentially 'nonlinear regression' - perhaps this is not a sufficiently strong model to express humanlike behaviour.
Despite the 'Universal function approximation' property of ANNs, what if human intelligence depends on some as-yet-unguessed mechanism of the physical world?
With respect to your question about "the only way":
Even if (physical) neural mechanisms somehow actually were the only route to intelligence (e.g. via Penrose's quantum microtubules), how could that be proved?
Even in the formal world of mathematics, there's a saying that "Proofs of non-existence are hard". It scarcely seems conceivable that, in the physical world, it would be possible to demonstrate that intelligence could not arise by any other mechanism.
Moving back to computational systems, note that Stephen Wolfram made the interesting observation in his book 'A New Kind of Science' that many of the apparently distinct mechanisms he observed seem to be capable of 'Universal Computation', so in that sense there's nothing very particular about ANNs.

It depends on what you consider "true artificial intelligence". But this probably means to be able to think like a human - and perhaps, do so in a more rational manner, as in the human brain emotion comes before ratio.
It would seem that a neural network, or a genetic algorithm that evolves neural networks, is the closest way - mimicking humans.
However, the traditional counter-argument to this is that we tried to do the same with flight. We tried to copy nature, mimick the birds - trying to fly by flapping wings. But eventually we made airplanes that did not rely on flapping their wings.
In AI, there are far more variables than in aerodynamics. So it is quite likely that a human-like intelligence can be attained by other methods than neural networks.
In the end, neural networks are one approach to machine learning. There are others, all governed by the rules for what can and cannot be learnt. (There is a field called Computational Learning Theory that covers this).
Although it is possible to extend learning systems beyond what can be learnt according to COLT, this means that such a learning system - neural network or otherwise - is essentially flawed, and will draw wrong conclusions at one point or another.

To have any chance at answering this, you'd first need a rigorous definition of "true artificial intelligence", which we don't have.  And even if you had that, the best answer would probably be "nobody knows."  We don't even understand exactly how human intelligence (which is probably the best model of intelligence we have available to study) works.  What we do know (or think we know) is that ANN's are at best a very superficial replica of brain function.  It may turn out that they're absolutely the wrong path to achieving "true artificial intelligence" although I expect most people would be surprised if that turned out to be the case.
What probably wouldn't be so surprising would be if some other technique emerged which is better than ANN's, OR if it turns out that you need an ensemble of techniques.  Personally I think it's close to self-evident that the brain works largely in a probabilistic fashion, but it's also clear that we do sometimes use symbolic processing / deductive logic / rules / etc.  And right now, ANN's don't give you much in the way of reasoning, deduction, etc.  So we may ultimately find that we have to combine a probabilistic approach like ANN's with other techniques - maybe Inductive Logic Programming or something of that nature.


text:
How do I decide the optimal number of layers for a neural network?
How do I decide the optimal number of layers for a neural network (feedforward or recurrent)?

See also the question How to choose the number of hidden layers and nodes in a feedforward neural network? at CrossValidated SE.

There is a technique called Pruning in neural networks, which is used just for this same purpose.
The pruning is done on the number of hidden layers. The process is very similar to the pruning process of decision trees. The pruning process is done as follows:

Train a large, densely connected, network with a standard training
algorithm
Examine the trained network to assess the relative importance of the
weights
Remove the least important weight(s)
retrain the pruned network
Repeat steps 2-4 until satisfied

However, there are several optimized methods for pruning neural nets, and it is also a very active area of research.

A symmetric approach is the common "grid search" applied to the network architecture. Start small (so fast), and automatically try larger architectures. All this is just brute force, though, so it is expensive. Yet, when we can start small, the first stages can go pretty fast, and give a better idea of what to aim for.

This answer is incorrect. Pruning is a method applied onto the weights, not a method to determine the number of layers (a hyperparameter).

You can take a look at bayesian hyperparameter optimization as a general method of optimizing loss (or anything) as a function of the hyperparameters. But note that in general the deeper your network the better, so optimizing loss as a function of number of layers isn't a very fun thing to do.
Grid search and a bit of common sense (as learnt by seeing many examples) should be your best bet.


text:
How could emotional intelligence be implemented?
I've seen emotional intelligence defined as the capacity to be aware of, control, and express one's emotions, and to handle interpersonal relationships judiciously and empathetically.

What are some strategies for artificial intelligence to begin to tackle this problem and develop emotional intelligence for computers?
Are there examples where this is already happening to a degree today?
Wouldn't a computer that passes a Turing test necessarily express emotional intelligence or it would be seen as an obvious computer?
Perhaps that is why early programs that pass the test represented young people, who presumably have lower emotional intelligence.

An artificial equivalent of https://en.wikipedia.org/wiki/Theory_of_mind is likely to be necessary, though it's hard to say how it could/should be implemented.

Architectures for recognizing and generating emotion are typically somewhat complex and don't generally have short descriptions, so it's probably better to reference the literature rather than give a misleading soundbite:
Some of the early work in affective computing was done by Rosalind W. Picard. There is a research group at MIT specializing in this area.
Some of the more developed architectural ideas are due to Marvin Minsky.
A pre-publication draft of his book, The Emotion Machine, is available via Wikipedia.
Emotional intelligence would certainly seem to be a necessary component of passing the Turing test - indeed, in the original Turing test essay in Computing Machinery and Intelligence implied some degree of "Theory of Mind" about Mr. Pickwick's preferences:

Yet Christmas is a Winter’s day, and I do not think Mr. Pickwick would mind the comparison.

I think your question fits nowadays more in the field of Human-Robot Interaction, which relies largely on vision for recognition of gestures and follow movements, as well as soft, natural movements as a response. Note that the movements of the face and hands belong to the most complex tasks, involving many muscles at a time.
I strongly recommend the film Plug & Pray to have an idea of what people are researching in this area.
You may also find Eliza (which you can try here) interesting. It is classical in the history of AI and pretends to mimic an analyst (psychology). (I am thinking of Eliza not because of its emotional intelligence, but because it was apparently taken seriously by a couple of humans. Could this be taken as a sort of (approved) Turing test? What does it say about the humans it met?)
On the purely human end of the scale, I sometimes wonder about our (my) emotional intelligence myself. Would I want to implement such an intelligence in an artificial agent at all?

Emotions aren't something that you can implement - they're very complex. However, you can attempt to mimic them. Human emotions are closely related to conscious experience characterized by intense mental activity, which is based on interpretation of events.
Recent brain studies (including research in cognitive psychology and neurophysiology) suggests that human emotional assessment of every action or event plays an important role in human mental processes.
The recent 2016 Annual Meeting of the BICA Society brought together scientists from around the world to approach principles and mechanisms of human thought to create biologically inspired AI.
For example, in Samsonovich's (a professor in the Cybernetics Department at the MEPhI) proposal, the idea is to test AI in computer games which involves actions with emotional content, where AI may engage with players in different types of social relationships (such as trust, subordination or leadership).
Jonathan Gratch of the ICT, invented virtual characters capable of identifying and expressing emotions by communicating with humans in their natural language based on the situations where for example AI can deceive a human to achieve the desired result. The effect is obviously not achieved by re-creating human consciousness, but by achieving statistically adjusting parameters.
Researchers from the Institute of Cyber Intelligence Systems in MEPhI are hoping to be able to create in the near future virtual beings which are capable of planning, setting goals and establishing social relationships with humans, also by possessing both emotional and narrative intelligence which can interpret the context of events.
Source: Researcher proposes social emotions test for artificial intelligence

Emotions aren't something that you can implement [Citation needed]. This suggests that emotions are somehow on a different level than what Turing machines can run, and there is no element that shows that it is true (excluding religious arguments, which are irrelevant).

@Fatalize "and there is no element that shows that it is true" [citation needed]. Emotions are really complex and not fully understood. There's no evidence you can fully implement them on a Turing machine. Maybe you can simulate them to some degree, but that's a different story.

So you may be familiar with Word2Vec, (W2V) which as Wikipedia describes1 "captures the linguistic contexts of words" using vector arithmetic. For example, subtract 'Paris' from 'France' and add 'Italy' and you get 'Rome'.
What you need is something like a Sentiment2Vec (S2V) that captures the similarities between emotional transitions. Something like: subtract 'fear' from 'sadness', add 'joy' and you get 'hope'. Or: subtract 'sting' from 'papercut', add 'smashed' and you get 'throbbing'.
The catch is that you don't have an easily accessible corpus of emotional contexts to train with, like you have with words. If you had a million hours of fMRI - mapping the transitions between emotions in hundreds of subjects - then you could use that data to build an S2V. You probably don't have that data though.
In the mean time, you could just build a W2V that specializes in sentiment. You could even try to use a current sentiment analysis engine to bootstrap it. Perhaps if you read enough text that says "I got a papercut and it stings" and "I smashed my finger and it's throbbing" then you could eventually produce an S2V. Children's books often use explicit language regarding emotional context ("this made the boy feel sad").
But words are still a far cry from the experiential context that a connectome map would provide. To test whether you have something useful or not, you might want to implement your S2V in a mouse foraging simulation - see whether it produces typical behavior and if any cooperative or competitive dynamics can organically grow out of your S2V.
Some further info on the subject:
In 2014, Glasgow University claimed2 that there are four primary emotions: happiness, sadness, fear and anger.
This website3 provides nice (if somewhat short) hierarchical breakdown of secondary and tertiary emotions under primary emotions.

References
1: en.wikipedia.org/wiki/Word2vec
2: www.bbc.com/news/uk-scotland-glasgow-west-26019586
3: changingminds.org/explanations/emotions/basic%20emotions.htm


text:
How can you simulate level of curiosity for a chatbot?
I'd like to know more about implementing emotional intelligence.
Given I'm implementing a chatbot and I'd like to introduce the levels of curiosity to measure whether user text input is interesting or not.
A high level would mean the bot is asking more questions and is following the topic. A lower level of curiosity makes the bot not asking any questions and changing the topics.
Less interesting content could mean the bot doesn't see any opportunity to learn something new or it doesn't understand the topic or doesn't want to talk about it, because of its low quality.
How this possibly can be achieved? Are there any examples?

It's possible to implement a form of curiosity-driven behavior without requiring full 'emotional intelligence'. One elementary strategy would be to define some form of similarity measure on inputs.
More generally, Jurgen Schmidhuber has pioneered work on 'Artificial Curiosity/Creativity' and 'Intrinsic Motivation' and has written a number of papers on the subject:

Artificial Curiosity
Intrinsic Motivation

Here is a video of a nice associated presentation.

I think "curiosity" in AI would signify a 'desire to search.' It's an interest, that is experienced by some agent, in making something known that was previously unknown.
So to define how much curiosity a chat bot should have, we should:

Specify what kinds of information the agent prefers knowing.
Measure how much information is unknown about those preferred subjects. ('what is the user's name?' or 'What does the user need help with?')
Measure the difficulty in making each unknown fact known.
Sort unknown facts by difficulty of finding the answer.
Set the "desire to search" on the highest ranking unknown fact.

While simplistic, those steps would constitute a state of affairs sufficient to describe "curiosity," in my opinion.


text:
What limits, if any, does the halting problem put on Artificial Intelligence?
Given the proven halting problem for Turing machines, can we infer limits on the ability of strong Artificial Intelligence?

Does the halting problem imply any limits on human cognition?
Yes, absolutely--that there are pieces of code a human could look at and not be sure whether or not it will halt in finite time. (Certainly there are pieces of code that a human can look at and say "yes" or "no" definitely, but we're talking about the ones that are actually quite difficult to analyze.)
The halting problem means that there are types of code analysis that no computer could do, because it's mathematically impossible. But the realm of possibility is still large enough to allow strong artificial intelligence (in the sense of code that can understand itself well enough to improve itself).

Halting problem means that no single ( finite) method can decide if any program will stop at finite time. It doesn't mean there are problems which cannot be solved ( which of course exists but the causes are usually different)

The halting problem is an example of a general phenomenon known as Undecidability, which shows that there are problems no Turing machine can solve in finite time. Let's consider the generalization that it is undecidable whether a Turing Machine satisfies some non-trivial property P, called Rice's theorem.
First note that the halting problem applies only if the Turing machine takes arbitrarily long input. If the input is bounded, it is possible to enumerate all possible cases and the problem is no longer undecidable. It might still be inefficient to calculate it, but then we are turning to the complexity theory, which should be a separate question.
Rice's theorem implies that an intelligence (a human) cannot be able to determine whether another intelligence (such as an AGI) possesses a certain property, such as being friendly. This does not mean that we cannot design a Friendly AGI, but it does mean that we cannot check whether an arbitrary AGI is friendly. So, while we can possibly create an AI which is guaranteed to be friendly, we also need to ensure that IT cannot create another AI which is unfriendly.

I've broken out the quantum question aspect out to a new question at: http://ai.stackexchange.com/q/186/55


text:
How can fuzzy logic be used in creating AI?
Fuzzy logic is the logic where every statement can have any real truth value between 0 and 1.
How can fuzzy logic be used in creating AI? Is it useful for certain decision problems involving multiple inputs? Can you give an example of an AI that uses it?

A classical example of fuzzy logic in an AI is the expert system Mycin.
Fuzzy logic can be used to deal with probabilities and uncertainties.
If one looks at, for example, predicate logic, then every statement is either true or false. In reality, we don't have this mathematical certainty.
For example, let's say a physician (or expert system) sees a symptom that can be attributed to a few different diseases (say A, B and C). The physician will now attribute a higher likelihood to the possibility of the patient having any of these three diseases. There is no definite true or false statement, but there is a change of weights. This can be reflected in fuzzy logic, but not so easily in symbolic logic.

My impression is that fuzzy logic has mostly declined in relevance and probabilistic logic has taken over its niche. (See the comparison on Wikipedia.) The two are somewhat deeply related, and so it's mostly a change in perspective and language.
That is, fuzzy logic mostly applies to labels which have uncertain ranges. An object that's cool but not too cool could be described as either cold or warm, and fuzzy logic handles this by assigning some fractional truth value to the 'cold' and 'warm' labels and no truth to the 'hot' label.
Probabilistic logic focuses more on the probability of some fact given some observations, and is deeply focused on the uncertainty of observations. When we look at an email, we track our belief that the email is "spam" and shouldn't be shown to the user with some number, and adjust that number as we see evidence for and against it being spam.


text:
How does Lucas's argument work?
In Minds, Machines and Gödel (1959), J. R. Lucas shows that any human mathematician can not be represented by an algorithmic automaton (a Turing Machine, but any computer is equivalent to it by the Church-Turing thesis), using Gödel's incompleteness theorem.
As I understand it, he states that since the computer is an algorithm and hence a formal system, Gödel's incompleteness theorem applies. But a human mathematician also has to work in a formal axiom system to prove a theorem, so wouldn't it apply there as well?

Yes, it applies. If a statement cannot be derived in a finite number of steps, then it doesn't matter if the person trying to prove it is a human or a computer.
The mathematician has one advantage over a standard theorem proving algorithm: the mathematician can "step out of the system" (as Douglas Hofstadter called in Gödel, Escher, Bach), and start thinking about the system. From this point of view, the mathematician may find that the derivation is impossible.
However, an AI for proving theorems could be programmed to recognize patterns in the derivation, just like our hypothetical mathematician, and start reasoning about the formal system to derive properties of the formal system itself.
Both the AI and the mathematician would still be bound by the laws of mathematics, and not be able to prove a theorem if it was mathematically improvable.

After he lays out his argument, he deals with some counterarguments. The following looks like the weakest one to me:

We can use the same analogy also against those who, finding a formula their first machine cannot produce as being true, concede that that machine is indeed inadequate, but thereupon seek to construct a second, more adequate, machine, in which the formula can be produced as being true. This they can indeed do: but then the second machine will have a Gödelian formula all of its own, constructed by applying Gödel's procedure to the formal system which represents its (the second machine's) own, enlarged, scheme of operations. And this formula the second machine will not be able to produce as being true, while a mind will be able to see that it is true. And if now a third machine is constructed, able to do what the second machine was unable to do, exactly the same will happen: there will be yet a third formula, the Gödelian formula for the formal system corresponding to the third machine's scheme of operations, which the third machine is unable to produce as being true, while a mind will still be able to see that it is true. And so it will go on.

In short, by making the system more complex, it can see the inadequacy of a less complex system, but a yet more complex system can see its inadequacy. But from whence comes the claim that a mind could see the inadequacy in the nth machine? If, say, the Gödelian formula had as many components to it as a human brain had neurons, it seems suspect to claim that the human could evaluate that formula and identify that it is in fact a Gödelian formula, rather than a similar but not quite identical sentence.


text:
Does the recent advent of a Go playing computer represent Artificial Intelligence?
I read that in the spring of 2016 a computer Go program was finally able to beat a professional human for the first time.
Now that this milestone has been reached, does that represent a significant advance in artificial intelligence techniques or was it just a matter of even more processing power being applied to the problem?
What are some of the methods used to program the successful Go-playing program?
Are those methods considered to be artificial intelligence?

Here is a related question.

There are at least two questions in your question:

What are some of the methods used to program the successful go playing program?

and

Are those methods considered to be artificial intelligence?

The first question is deep and technical, the second broad and philosophical.
The methods have been described in: Mastering the Game of Go with Deep Neural Networks and Tree Search.
The problem of Go or perfect information games in general is that:

exhaustive search is infeasible.

So the methods will concentrate on shrinking the search space in an efficient way.
Methods and structures described in the paper include:

learning from expert human players in a supervised fashion
learning by playing against itself (reinforcement learning)
Monte-Carlo tree search (MCTS) combined with policy and value networks

The second question has no definite answer, as you will have at least two angles on AI: strong and weak.

All real-world systems labeled "artificial intelligence" of any sort are weak AI at most.

So, yes, it is artificial intelligence, but it is non-sentient.

It doesn't make much sense to have a single threshold with "unintelligent" below it and "intelligent" above it.
I think it makes more sense to have a gradation of intelligence by cognitive task. Inverting a matrix is a 'cognitive task,' and one where working memory pays off immensely; computers have been much better at that cognitive task than humans for a long time.
What the AlphaGo victory represents has several components. One is that we have algorithms that are competitive with the best board-game playing humans at doing tactical and strategic thinking in the well-described world of Go. Another is that the deeper structure of the human visual system seems to have been duplicated, and so we have algorithms that can recognize patterns as well as humans--with very limited resolution. (AlphaGo is seeing one pixel per stone, whereas we have very, very high-resolution eyes and the visual cortex to match.)
Different people have different intuitions, but it seems to me that visual intelligence is a huge component of human intelligence in general. If we know most of the secrets of human visual intelligence, that means there might be many tasks that computers could now perform as well as humans (if provided the correct training data).

Now that this milestone has been reached, does that represent a significant advance in artificial intelligence techniques or was it just a matter of ever more processing power being applied to the problem?

Neither, really. It is a milestone and a significant advance in computers beating humans in games, but the techniques used are only relevant to that game, not for other purposes in AI.
The solution lies in humans analyzing the game and implementing algorithms for finding a good move. This is the main reason that a computer can beat the humans, together with the fact that it can calculate much faster and that it doesn't make really bad moves by not seeing something.
Processing power helps, but the game-tree complexity for Go is very large, estimated to be larger than 10200, whereas the game-tree complexity for chess is only 10120 (known as the Shannon number), so chess is less hard. This means that for neither chess nor go a database can be created with all possible positions.
The fact that Deep Blue beat Kasparov in a six-game match in 1997 was quite a development since this was one of the first "hard" games where a computer beat a top human. But it still isn't really Artificial Intelligence, more analyzing the game. Implementing an opening and endgame book was a large part, the middle game was done using analysis, I don't know the details.

We've had many discussions on what constitutes Artificial Intelligence, and my takeaway has been that decision-making is the core requirement of AI, regardless of the optimality of that decision.
In this conception, Nimatron (1939, US2215544A) might be thought of as the first proper AI, pending verification of a a fabled Babbage Tic-Tac-Toe machine.
But, the question as to whether a simple switch represents the most basic form of intelligence has also been raised...
I think a distinction between these decision-making devices and earlier algorithmic implementations such as water clocks, is that the water clocks cannot be said to make a decision in the sense of maximizing chance of success at some goal.