text:
Could an AI think laterally while avoiding "ethically suboptimal" choices?
In the recent PC game The Turing Test, the AI ("TOM") needs help from Ava to get through some puzzle rooms. TOM says he is unable to solve the puzzles because he is not allowed to "think laterally." Specifically, he says he would not have thought to throw a box through a window to solve the first room. His creators, the story goes, turned that capability off because such thinking could produce "ethically suboptimal" solutions, like chopping off an arm to leave on a pressure plate.
Would all creative puzzle-solving abilities need to be removed from an AI to keep its results reasonable, or could we get some benefits of lateral thinking without losing an arm?

No, with a but. We can have creative yet ethical problem-solving if the system has a complete system of ethics, but otherwise creativity will be unsafe by default.
One can classify AI decision-making approaches into two types: interpolative thinkers, and extrapolative thinkers.
Interpolative thinkers learn to classify and mimic whatever they're learning from, and don't try to give reasonable results outside of their training domain. You can think of them as interpolating between training examples, and benefitting from all of the mathematical guarantees and provisos as other statistical techniques.
Extrapolative thinkers learn to manipulate underlying principles, which allows them to combine those principles in previously unconsidered ways. The relevant field for intuition here is numerical optimization, of which the simplest and most famous example is linear programming, rather than the statistical fields that birthed machine learning. You can think of them as extrapolating beyond training examples (indeed, many of them don't even require training examples, or use those examples to infer underlying principles).
The promise of extrapolative thinkers is that they can come up with these 'lateral' solutions much more quickly than people would be able to. The problem with these extrapolative thinkers is that they only use the spoken principles, not any unspoken ones that might seem too obvious to mention.
An attribute of solutions to optimization problems is that the feature vector is often 'extreme' in some way. In linear programming, at least one vertex of the feasible solution space will be optimal, and so simple solution methods find an optimal vertex (which is almost infeasible by nature of being a vertex).
As another example, the minimum-fuel solution for moving a spacecraft from one position to another is called 'bang-bang,' where you accelerate the craft as quickly as possible at the beginning and end of the trajectory, coasting at maximum speed in between.
While a virtue when the system is correctly understood (bang-bang is optimal for many cases), this is catastrophic when the system is incorrectly understood. My favorite example here is Dantzig's diet problem (discussion starts on page 5 of the pdf), where he tries to optimize his diet using math. Under his first constraint set, he's supposed to drink 500 gallons of vinegar a day. Under his second, 200 bouillon cubes. Under his third, two pounds of bran. The considerations that make those obviously bad ideas aren't baked into the system, and so the system innocently suggests them.
If you can completely encode the knowledge and values that a person uses to judge these plans into the AI, then extrapolative systems are as safe as that person. They'll be able to consider and reject the wrong sort of extreme plans, and leave you with the right sort of extreme plans.
But if you can't, then it does make sense to not build an extrapolative decision-maker, and instead build an interpolative one. That is, instead of asking itself "how do I best accomplish goal X?" it's asking itself "what would a person do in this situation?". The latter might be much worse at accomplishing goal X, but it has much less of the tail risk of sacrificing other goals to accomplish X.

Ethics involves the relationships of needs between two or more parties. As Matthew Graves said, if the AI lacks the sufficient human context (understanding of needs), it will produce seemingly perverse ethical behavior.
And let's be honest, some people would cut of other people's arms and put them on pressure plates. Even the best of us will not be able to sympathize with the needs of others with 100% accuracy - at best, we're guessing. And then there are those rare situations where I actually want you to cut off my arm and put it on a pressure plate, perhaps to save a loved one.
If we could make a thing that could sympathize with what a human might need in any given arbitrary situation, then we will have created either A) an artificial human intelligence (AHI) (which could be more or less fallible, like a human), or B) an oracle that can reason about all possible human needs on much faster than human time-scales - in which case you wouldn't need a conscious AI, as all human needs and solutions could be pre-computed via formal specification, which is probably absurd to consider.

You may consider the programming as an ethical part of the design as well. AI will act based on what has been instructed to it as ethically important or not.
It may/should even be part of the parameters that forge the process of finding solutions, which could allow for a more refine and creative solution.
We understand the basics of ethic in normal circumstances, but if we can't predict how any human will behave in an ethical conundrum we can enforce what an AI wouldn't do.
As long as we have control over the mechanism that drive an AI we sure have a responsability to inject ethical failsafes.
The problem lies in self taught AI with an ability to overrides directives.
(CF Asimov Laws.)
The way the AI is creative seems irrelevant in that case.

A lot of this depends on the breadth of consideration. For example, what would the medium and long term effects of the lateral thinking be? The robot could sever an arm for a pressure plate but it would mean that the person no longer had an arm, a functional limitation at best, that the person might bleed out and die/be severely constrained, and that the person (and people in general) would both no longer cooperate and likely seek to eliminate the robot. People can think laterally because consider these things - ethics are really nothing more than a set of guidelines that encompass these considerations. The robot could as well, were it to be designed to consider these externalities.
If all else fails,
Asimov's Laws of Robotics: (0. A robot may not harm humanity, or, by inaction, allow humanity to come to harm.) 1. A robot may not injure a human being or, through inaction, allow a human being to come to harm. 2. A robot must obey orders given it by human beings except where such orders would conflict with the First Law. 3. A robot must protect its own existence as long as such protection does not conflict with the First or Second Law


text:
What is the calcium equivalent role in neural networks
I understand that neural networks model biological neurons.  Each node in the network represents a neuron cell and the connections between nodes represent the connections between cells.  As in nature, a neuron fires an electrical signal to connected neurons based on some kind of threshold or function that mimics such.
Recent discoveries on how the brain works reveal the importance of calcium within the cells.  See http://link.springer.com/article/10.1007/BF01794675 for more information.  To summarize, calcium affects the regulation, stimulation and transmission of electrical activity as well as the destruction of neurones.
From my study of neural networks, there does not seem to be a calcium equivalent.  Having one would imply that the functions, connections and weights in an artificial network are configured during the training and execution process and can change over time.   I understand that back-propagation is used to train the weights, but have not seen anything that trains the function nor the connections (although a zero weight could imply no connection).
Does anyone know of such a network (or training algorithm)?  If so, do these networks perform better than a network that is pre-configured?

Neural networks don't model biological neurons.
They are at best inspired by biological neurons, in that they get excited by certain inputs and fire once the excitation crosses a threshold. And this second point even holds only approximately because the backpropagation algorithm needs smoothed out steps to learn by gradient descent. And backpropagation is not even inspired by biology, that would rather be hebbian learning.
Generally in machine learning people do what works. The connection to biology is tenuous at best. You will usually not find one to one correspondence of low level details between machine learning setups and biological neurons. For that you'll have to turn to brain simulations.

source: Stack Exchange

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

sort: votes


text:
Wouldn't an AI that specializes in making other AI be an AGI if they can cooperate?
If said AI can assess scenarios and decide what AI is best suited and construct new AI for new tasks. In sufficient time would the AI not have developed a suite of AIs powerful/specialized for their tasks, but versatile as a whole, much like our own brain’s architecture? What’s the constraint ?

You should send this question to Hollywood producers or news outlets. They will give you back many different highly unlikely scenarios. It is hard to make predictions, especially about the future.

If the AI can indeed assess arbitrary scenarios and come up with solutions to handle them, then it would indeed be an AGI.

What’s the constraint ?

It doesn't exist.  Current programmers are very good at developing AI that can handle specific tasks ("narrow AIs"), but it is currently impossible to build an AI that can assess and handle "general" situations (unlike your proposed algorithm, which possess that capacity).
Theoretically, we can have a program that can build other programs (genetic algorithms are arguably one such example), but handling arbitrary scenarios and problems requires a form of "general intelligence", which we don't know how to program. Therefore, we can't build this machine.
It's possible that we can built this machine, but we must first figure out  the hard problem of "general intelligence". We're nowhere near reaching that level.
If we figure out how to program "general intelligence", then it should be fairly simple to use your approach (building an AGI to assess scenarios and then build "narrow AIs" that can handle Those scenarios). Only then we can understand the AGI's limitations and weaknesses, and be able to identify probable constraints to its power. For example, it's possible that such an AGI may be slow in handling arbitrary scenarios and developing the "narrow AIs"...in which case, it may take an absurdly long period of time to develop "a suite of AIs powerful/specialized for their tasks".
But until we build the AGI itself, we won't be able to identify its faults or weaknesses. Going beyond that would be science-fiction speculation.

To build on Tariq Ali's answer...
There's no such thing as an AGI. The No Free Lunch (NFL) theorem states essentially that: any two optimization algorithms are equivalent when their performance is averaged across all possible problems. Specialization implies a loss of generality, not a gain.
With this AI generating AI, you're describing what I call an 'arbitrary machine generator' (AMG).
There are two types of AMGs: a species level and an individual level.
All species that evolve on earth are AMG - they can evolve to accommodate arbitrary niches, if the correct environmental constraints are present. This is proven by the fact that the species AMG processes on earth have produce humans, which are individual level AMGs. Individual level AMGs can produce arbitrary machines for arbitrary purposes on human time-scales.
The problem is that the simplest possible (and most general) AMG is a purely random machine generator. Any more specificity (and therefore complexity) to the AMG would constrain the domains it closes over. Which is fine, but optimizing a machine for a particular set of tasks means that you are unoptimizing the machine for some other particular set of tasks. Again, there's no free context.
Humans are AMGs, but we are only efficient at creating certain kinds of machines, using our imagination. Our imagination is built on a number of cognitive tools that, on the one hand, constrain what machines we can efficiently imagine, while, on the other hand, avail us to the open-ended set of all possible machines, via prior knowledge or brute force, random lookup.
In summary, when people say "general intelligence", they really mean "human-like intelligence". And, again, while human intelligence is an AMG, any given AMG that is optimized for generating machines of a particular type will be less optimized for generating machines of some other type(s). There's no free context. The most general search algorithm is a random walk - there is no way to improve the generality of the random walk, other than just speeding it up. And that's actually what humans do for many problems anyway - brute force, random searching, as fast as possible.

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


text:
When using neural networks to detect features in an image, how can locate that specific feature in the original image?
I understand how a neural network can be trained to recognise certain features in an image (faces, cars, ...), where the inputs are the image's pixels, and the output is a set of boolean values indicating which objects were recognised in the image and which weren't.
What I don't really get is, when using this approach to detect features and we detect a face for example, how we can go back to the original image and determine the location or boundaries of the detected face. How is this achieved? Can this be achieved based on the recognition algorithm, or is a separate algorithm used to locate the face? That seems unlikely since to find the face again, it needs to be recognised in the image, which was the reason of using a NN in the first place.

The recent Stanford deep learning course has touched on exactly this problem: localization and detection: see, for example, Lecture 8 Localization and Detection and Lecture 13 - Segmentation, soft attention, spatial transformers

This problem is called object detection.
If you have a trainings set of images with boxed objects you can just train a neural network to directly predict the box. I.e. the output has the same dimension as the input and the NN learns to assign each pixel the probability of belonging to a certain object.
If you don't have such a convenient dataset you could just recursively narrow the location down by feeding parts of the image to the network until you find the smallest part that still fully activates a certain classification.
In this paper they try a mixture of these two approaches.

The approach you listed here is not really an approach, this is very very vague idea of how someone can achieve some task. You basically told we have an algorithm f(image) = result and there can be infinite amount of real approaches to solve this.
In majority of CNN approaches the image travels through a convolution/pooling layers which reduces the dimensions of each current layer. In the end you end up with a significantly smaller layer which goes through the softmax and gets probabilities of different classes. This type of networks does not tell you where something was found, it just tells you that something was found somewhere in your original image.

To add to @BlindKungFuMaster's answer, the object detection problem in NN context isn't necessarily solved by using a network that produces output with the same size as the input. Actually this approach - assigning each pixel the object probability - better fits the Instance/ Semantic Segmentation problem.
To briefly review the common state of the art object detectors, there are mainly two families:

The two-stage approach (one stage find the bounding boxes by a variant of sliding window, another stage finds the object probabilities, some of the layers might be common to both stages) - from RCNN (propose boxes by the Selective Search algorithm, check if they contain an object by running CNN - AlexNet in this case - on each box, if a box contains an object run linear regression to tighten the box), through Fast-RCNN (Share the computations for all the boxes, use ROI pooling to select the region that corresponds to each box), Faster-RCNN (Speed up the region proposal stage by using a fully convolutional Region Proposal Network instead of the heavy Selective Search), R-FCN (Share all computations for both objects and box proposals), and Mask-RCNN that extends the faster-RCNN solution to semantic segmentation, but also solves better the detection problem by fitting the box coordinates+object features correspondence by using bilinear interpolation, replacing ROI pooling with ROI align.
The single-stage approach, such as SSD, DSSD, YOLO, YOLO2 and lastly RetinaNet with the focal loss, that in a single shot produce both boxes and objects scores, and work much faster that the two-stage approaches.

A great summary for object recognition, detection and segmentation is published here - highly recommended.


text:
Is a subset of a problem solution, used to recreate complete solution considered a heuristic?
This is a question about a nomenclature - we already have the algorithm/solution, but we're not sure whether it qualifies as utilizing heuristics or not.

feel free to skip the problem explanation:

A friend is writing a path-finding algorithm - an autopilot for an
  (off-road) vehicle in a computer game. This is a pretty classic
  problem - he finds a viable, not necessarily optimal but "good enough"
  route using the A* algorithm, by taking the terrain layout and vehicle
  capabilities into account, and modifying a direct (straight) line path
  to account for these. The whole map is known a'priori and invariant,
  though the start and destination are arbitrary (user-chosen) and the
  path is not guaranteed to exist at all.
This cookie-cutter approach comes with a twist: limited storage space.
  We can afford some more volatile memory on start, but we should free
  most of it once the route has been found. The travel may take days -
  of real time too, so the path must be saved to disk, and the space in
  the save file for custom data like this is severely limited. Too
  limited to save all the waypoints - even after culling trivial
  solution waypoints ('continue straight ahead'), and by a rather large
  margin, order of 20% the size of our data set.
A solution we came up with is to calculate the route once on start,
  then 'forget' all the trivial and 90% of the non-trivial waypoints.
  This both serves as a proof that a solution exists, and provides a set
  of points reaching which, in sequence, guarantees the route will take
  us to the destination.
Once the vehicle reaches a waypoint, the route to the next one is
  calculated again, from scratch. It's known to exist and be correct
  (because we did it once, and it was correct), it doesn't put too much
  strain on the CPU and the memory (it's only about 10% the total route
  length) and it doesn't need to go into permanent storage (restarting
  from any point along the path is just a subset of the solution
  connecting two saved waypoints).

Now for the actual question:
The pathfinding algorithm follows a sparse set of waypoints which by themselves are not nearly sufficient as a route, but allow for easy, efficient  calculation of the actual route, simultaneously guarantying its existence; they are a subset of the full solution.
Is this a heuristic approach?
(as I understand, normally, heuristics don't guarantee existence of a solution, and merely suggest more likely candidates. In this case, the 'hints' are taken straight out of an actual working solution, thus my doubts.)

Since you mention the A* algorithm, then you are definitely using a heuristic somewhere in there, at least with the A* algorithm while solving the subproblems using the straight-line distance as your heuristic function.
Although your approach does not seem to incorporate a "shortcut mathematical formula" as a heuristic after that, it does us a precalculated heuristic table as a reference and that may qualify as a heuristic. Wikipedia page here says (although without citation) the following which does seem to describe what you are doing where your heuristic is not a fixed but a precalculated function/table:

A heuristic function, also called simply a heuristic, is a function
  that ranks alternatives in search algorithms at each branching step
  based on available information to decide which branch to follow. For
  example, it may approximate the exact solution.

On another note, your method also seems to have hints of dynamic programming since you use the precalculated and stored solutions to subproblems and instead of recalculating every time.
I wonder if the term approximate dynamic programming would fit this situation as a non-stochastic version with no uncertainties? Unfortunately I could not find any simple description or categorization for that term.

Good catch with A* using heuristics.

A 'heuristic' is simply a 'rule-of-thumb', i.e. something which doesn't guarantee an optimal solution to a problem.
Beyond the above notion (certainly within the discipline of optimization), the notion of what constitutes a heuristic is not particularly strict, and could certainly include hints for constructing a new solution from parts of a previous one, as you are doing.
A related concrete example is the "nearest neighbour heuristic" for the Travelling Salesman Problem, in which a solution is constructed by starting at some random city and iteratively choosing the nearest. The resulting completed tour is then used as an initial input to some more sophisticated optimization procedure.

Whether or not a label fits any particular instance depends on what you're using the label for. If something specific is riding on whether this approach is a 'heuristic' or not, that context is important.
But I wouldn't call this a heuristic, because I think of that as a shortcut for solving a problem, not either storing a solution or reformulating the problem (which is how I'd think of this).


text:
Given unlimited time and a perfect fitness function, could a genetic program solve any problem?
Obviously this is hypothetical, but is true? I know "perfect fitness function" is a bit hand-wavy, but I mean it as we have a perfect way to measure the completion of any problem.

Of course, you will have to then assume that a solution to the problem is indeed expressible by some element of the program space. For example, if the problem is to compute Ackerman's function, then that can't be solved by GP with a primitive recursive function set.

This question is unclear to me. What is a genetic program? Do you mean a genetic programming algorithm (which is able to evolve programs)?

Yes.
A totally random algorithm could solve any problem given unlimited time and a perfect fitness function. All you need to do is give the GA some new random population members each generation and you're guaranteed to find the solution eventually. Even if you keep only descendants of the previous generation, setting the mutation rate and number of crossovers high enough could effectively get you random individuals.

Of course this doesn't have much to do with genetic programming. If there is a solution, you can find it with random guessing given unlimited time. I would provide you even with an bounded time algorithm: If there is a solution, you can find it by trying all possible solutions.

@BlindKungFuMaster You missed the magical words "Brute force" :)

As per the answer to this AI SE question,
the presence of mutation makes a GA into a global search algorithm, i.e. it will eventually visit each point in the search space.
How efficiently it will do so is indeed related to the quality of the fitness function:
A 'perfect fitness function' could conceivably mean any of the following:

A function  which takes on an optimal value iff it is applied to
an optimal solution.
A function which forms a quadratic bowl
(Newton's method can solve this in one step).

A degenerate case of 1. is a 'Needle in a haystack' function, which returns the same arbitrarily poor value everywhere that isn't an optimum, and 2. unfortunately doesn't arise very often in practice.
Hence, the role of a well-designed fitness function is to impose a gradient on the search process, which in practice will generally lie somewhere in-between 'Needle in a haystack' and 'Quadratic bowl'.
The presence of some form of smoothness in the fitness function is one mechanism that allows better performance than random or exhaustive methods.

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


text:
How can we create an AI to develop mobile apps?
There are AI creating game, content and more.
I'm thinking on how can AI develop mobile app itself?
The computer languages might easy for AI to learn.
AI can learn a lot from good open source project in github.
The trend prediction can help AI to select the topic for creating a great apps.
There are lots of details to let AI create a great apps.

We don't know how to do that yet. The problem is one of scale:
Despite many years of research into program synthesis via heuristic methods, it's still not possible to automatically create programs (e.g. via Genetic Programming (GP), Grammatical Evolution (GE) or Learning Classifier Systems (LCS)) that are thousands of lines long, whether that's for mobile or any other application area.
Contrary to popular belief, alternative formal methods approaches can indeed be used to create sizeable programs, but the kind of interaction that a mobile app would typically require is not easily specified in this way.
The scale at which heuristic approaches are currently viable is closer to the scale of expressions (e.g. single program statements) than entire programs. An intermediate approach is therefore to provide a program template and let GP etc generate the missing parts of the template.
This paper describes how to combine Machine Learning with the 'Template Method' Design Pattern in order to create larger programs than would otherwise be possible, giving the specific example of a 'hyper-quicksort'.


text:
Will it ever be possible to construct a neural network that could have the features of human brain?
I have a question. Will we be able to build a neural network that thinks abstractly, has the creativity, feels and is conscious?

So basically an AGI (Artificial General Intelligence)?

Maybe in the distant future they could build a computer powerful enough to simulate the individual neurons of an entire human brain. Then they could carefully copy/paste the connectivity of a sample brain into the computer simulation.
Given that this extreme seems physically possible, it stands to reason that much simpler/smaller alternatives could be engineered in the future assuming continuous advancements in technology.


text:
Network representation for Q-Learning in carrom
I am trying to build an agent to play carrom. The problem statement is roughly to estimate three parameters (normalized) :

force
angle of striker
position of strike

Since the state and action space both are continuous, I thought of discretizing the output such that I have 270 [ valid angles from -45 to 225 degrees ] outputs for the angle, 10 outputs for force [ranging from 0 to 1] and 20 outputs for the position [ranging from 0 to 1].
Thus I will have 300 output of my neural network, but this number seems a bit too high compared to normal neural networks in practice.
I was wondering if there is a better way of approaching the problem considering the fact that there are multiple parameters to a particular action.
Is there a generic way to approach such problems represented in 2D space.

Discretizing the output will probably be counter-productive in this situation; it would remove flexibility by taking away the fine-grained continuous ranges between each discretization bucket, but also blow up the size of the network, reducing manageability and performance. Fragmenting the outputs into buckets in this way may also lead to information loss and more difficulty in convergence because of the fact that each bucket is partially isolated from the others.
After causing myself needless hassle in the past by mismatching input and output dimensions, I'd simply do this if I were in your shoes: 1) keep it simple and use 3 continuous (well, semi-continuous, depending on the highest precision your programming framework allows) outputs for all of the above reasons; 2) clamp the angles between -45 to 225 by whatever method works best for you, like ceiling/floor hard clamping, adding weight terms, etc.; 3) go big on the hidden layer(s) to maximize information sharing across the inputs and eventual outputs, force, angle of strike, position of strike, etc. This is more likely to fine-tune the precision of the outputs, thereby making good use of the semi-continuous scales.
I'm also wondering if a convolutional neural net might work in this situation; their most popular use case is in image processing, but I don't see why you can't treat the force, angle and position as surrogate spatial dimensions. I'm not sure how many or what type of inputs you have, but 3 continuous outputs might be conducive to a 3D rather than a 2D space. Convolutionals are often used for those, as well as higher-dimensional and temporal data. I hope that helps.


text:
Is the QuickDraw with Google neural net a convolutional neural network?
Does anyone know, or can we deduce or infer with high probability from its characteristics, whether the neural network used on this site
https://quickdraw.withgoogle.com/
is a type of convolutional neural network (CNN)?

Checkout https://github.com/tensorflow/magenta/tree/master/magenta/models/sketch_rnn

@RonakPoriya Is the link based on Google Quick Draw code or part of the project?

I believe they don't use CNNs. The most important reason why it's because they have more information than a regular image: time. The input they receive is a sequence of (x,y,t) as you draw on the screen, which they refer as "ink". This gives them the construction of the image for free, which a CNN would have to deduce by itself.
They tried two approaches. Their currently most successful approach does the following:

Detect parts of the ink that are candidates of being a character
Use a FeedForward Neural Network to do character recognition on those candidates
Use beam search and a language model to find most the most likely combination of results that results into a word

Their second approach is using an LSTM (a type of Recurrent Neural Network) end-to-end. In their paper they say this was better in a couple languages.
Source: I was an intern in Google's handwriting team in summer 2015 (on which I believe quickdraw is based), but the techniques I explained can be found in this paper.

It looks like that it used convolution and recurrent neural network. There is a dataset webpage used in Quick Draw project and it led to Recurrent Neural Networks for Drawing Classification GitHub page. The GitHub link showed the neural network structure as well.
Here is the neural network structure from the GitHub page:

The current Quick Draw might be evolved from the neural network structure at the GitHub because the webpage written in 2020.


text:
How is it possible for an AI to interact with someone without a computer screen?
As you can see, there is no computer screen for the computer, thus the AI cannot display an image of itself.  How is it possible for it to see and talk to someone?

There are very many ways how a can interact with the computer,apart from the screen.Voice Recognition and webcam.But you're question lacks some in depth research.

So an AI does not need a computer screen in order to see?

There are many communication methods that could be used by an artificial intelligence. Artificial intelligence can be integrated to various things including robots, phones, IoT and many others. Primary ways of human communications are  either visual or auditory, therefore an natural way for it to communicate with a human is through voice, text, images and videos. The output does not have to be limited to screens but can be anything from refrigerators to speakers.
Hope this helped.

Would a camera with facial recognition and speaker make the AI be able to see and talk?

If so, does facial recognition helps AI see someone with better quality?

For any visual communication, it fouls use sensors such as cameras as you mentioned or others such as inferred, temperature sensor and etc to detect the environment

so is that a no to my questions?

Your question was how can AI communicate and I have explained it for you.

I mean is the camera and speaker one of the answers?

Yes definitely. You're welcome for the answers :)

Ps facial recognition helps the AI recognise people rather than "see" them better. You are obviously lacking some knowledge and research in to this topic...

of course, so even when there's no facial recognition, the AI can still see if the camera is still present

Yes i would say that statement is somewhat correct but it depends on what you define "see" as in terms of AI

"How is it possible for it to see and talk to someone?"
OK, unfortunately this is quite vague... but I am going to try my best.
The monitor of the computer really doesn't change the ability for it to communicate. For instance, voice recognition is natural to humans along with visual factors. So sensors involving auditory elements assists the AI with this.
Now I commented that the question was vague because you said "there is no computer screen for the computer, ****thus the AI cannot display an image of itself****.
Even though the AI can not see does not mean it can not communicate. Those who are blind still have ways of communication, just in a different manner. Sure, they can not recognize one with their own eyes, but they can by touch, and read with braille. Now compared to AI communication, the braille is to any other form of sensor.
Sorry for jumping all over the place, also I did not mean to offend anyone with my comparison... :/


text:
Neural Networks unmatched on MNIST?
I remember reading or hearing a claim that at any point in time since the publication of the MNIST dataset, it has never happened that a method not based on neural networks was the best given the state of science of that point in time.
Is this claim true?

To quote the relevant Wikipedia article:

The original creators of the database keep a list of some of the methods tested on it.[7] In their original paper, they use a support-vector machine to get an error rate of 0.8%

Feel free to look up that original paper, but to me the quote strongly suggests that the first record holder was a support vector machine.

Edit
As liori points out the quote is misleading: In the original paper Yann LeCun et al. actually tried a slew of methods and one version of ConvNet scored best (0.7).
But according to the MNIST-webpage, after that initial paper, DeCoste and Scholkopf, MLJ 2002, reached an error of 0.56 with a SVM. So if that webpage is complete, the claim is still false.

Seems like the paper referenced in [5] (http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf) on Wikipedia states both the V-SVM result of 0.8 and the boosted LeNet-4 result of 0.7, so… not in this case.

[5] is actually this link: http://yann.lecun.com/exdb/mnist/ ,but you still seem to be right.

I don't understand how this answers the original question, which was supposedly asking if any other technique surpassed NNs on the MNIST task, not if before NNs there was a technique that performed better than them, as the OP wrote "since the publication of the MNIST dataset, it has never happened".


text:
How to make a bot to learn from previous games
How to train a bot, given a series of games in which he did (initially random) actions, to improve its behavior based on previous experiences?
The bot has some actions: e.g. shoot, wait, move, etc. It's a turn based "game" in which, for know, I'm running the bots with some objectives (e.g. kill some other bot) and random actions. So every bot will have a score function that at the end of the game will say, from X to Y (0 to 100?) if they did well or not.
So how to make the bots to learn of their previous experiences? Because this is not a fixed input as the neural networks take, this is kind of a list of games, each one in which the bot took several actions (one by every "turn"). The IA functions that I know are used to predict future values.. I'm not sure is the same.
Maybe I should have a function that gets the "more similar previous games" that the bot played and checked what were the actions he took, if the results were bad he should take another action, if the results were good then he should take the same action. But this seems kind of hardcoded.
Another option would be to train a neural network (somehow fixing the problem of the fixed input) based on previous game actions and to predict the future action's results in score (something that I guess it's similar to how chess and Go games work) and choose the one that seems to have better outcome.
I hope this is not too abstract. I don't want to hardcode much stuff in the bots, I'd like them to learn by their own starting from a blank page.

I'm not sure how to answer your question, but I would point you to OpenAI Universe framework which seems to be quite fresh implementation of reinforcement learning envinroment: https://github.com/openai/universe-starter-agent. It is Open Source so you might find some inspiration there.

Reinforcement learning
The problem that you describe, namely, choosing a good sequence of actions based on a reward/score received based on the whole sequence (and possibly significantly delayed), is pretty much the textbook definition of Reinforcement learning.
As with quite a few other topics, deep neural networks currently seem to be a promising way for solving this type of problems. This may be a beginner-friendly description of this approach.

If it is a game you can try a simple weightage calculation where if the bot perform an action that yields a positive result - killed an enemy, gained an advantageous position etc. Add a 'weight' to that action that in similar circumstances the chances of performing that action that will lead to a positive result is higher.
Yet due to the chance of not performing an action that was remembered to yield positive results, there is a little bit of 'randomness' and also a chance to discover new possibilities. Just remember not to let a single occurrence shift the weightage too much or allow a single action's weightage to become so high that the AI stops trying different actions on similar situations.


text:
Feasibility of generating large images with a convnet
I've spent the past couple of months learning about neural networks, and am thinking of projects that would be fun to work on to cement my understanding of this tech.
One thing that came to mind last night is a system that takes an image of a movie poster and predicts the genre of the movie. I think I have a good understanding of what'd be required to do this (put together a dataset, augment it, download a convnet trained on imagenet, finetune it on my dataset, and go from there).
I also thought that it would be pretty cool to run the system backwards at the end, so that I could put in e.g. a genre like 'horror' and have the system generate a horror movie poster. I expect that it will be very bad at this because I'm not a team of expert researchers, but I think I could have some fun hacking on it even if it only ever generated incomprehensible results.
Here's what I'm having trouble understanding: on the one hand, all the convnets whose architecture I've seen described seem to rely on being given very small, square input images (on the order of 220px by 220px iirc), and movie posters are rectangular, and a generated poster would have to be of a larger size in order for a human to make any sense of it.  I've seen several examples of papers where researchers use convnets to generate images, e.g. the adversarial system that generates pictures of birds and flowers, and a system that generates the next few frames of video when given a feed of a camera sweeping across the interior of a room, but all of those generated images seemed to be of the small square size I've been describing.
On the other hand, I've seen lots of "deep dream" images over the past year or so that have been generated by convnets and are of a much larger size than ~220px by ~220px.
Here's my question: is it possible for me to build the system I describe, which takes a movie genre and outputs a movie poster of a size like e.g. 400px by 600px? [I'm not asking about whether or not the resulting poster would be any good - I'm curious about whether or not it's possible to use a convnet to generate an image of that size.]
If it is possible, how is it possible, given that these systems seem to expect small, square input images?

The way you would recognize images (image -> genre) would be very different from the other way around (genre -> image). For the former you are correct on what would be involved.
For the latter, if you want large images then GANs are indeed the way to go. Currently the largest images we can generate are on the order of 220 x 220 pixels, mostly due to memory constraints on the GPU. There is no fundamental problem with having rectangular images, it just so happens that we use squares. You would be able to use identical architectures to train on rectangular data as well.
The reason that some generated images you see (e.g. from DeepDream or NeuralStyle) are larger is that it's not a GAN. Both of these are not generative models in a standard sense, even if they do technically "generate" images. Instead, they merely modify an existing image by running backprop on a specifically designed loss function.
TLDR: your movie genre recognition idea is sound. For generation, have a look at things like this (https://github.com/Newmu/dcgan_code), where Alec generated album covers instead of posters. If you have enough data it will do something half sensible.

There is a fundamental difference between Generative Models and Discriminative Models, to simplify it we could say that

given $S$ Semantic Space (low dimensionality) and
given $A$ Appearance Space (high dimensionality, e.g. space of $W \times H$ images)

the Discriminator learns the function $f(A) \rightarrow S$ and the Generator learns the function $g(S) \rightarrow A$
According to this formalism we can say that $g \neq f^{-1}$ and a simple reason for this is $f$ is not invertible because it is not injective, in fact 2 different horror movie posters will be assigned the same label “horror movie” (assuming the network works well :) )
So you have to find another way to define a mapping from $S$ to $A$ and this kind of job is related to the Generative Models
Certainly GAN are state of the art in image generation but technically they are not the only choice, e.g. you could use a VAE as the Decoder Subnetwork is a generative model
However from a practical point of view do not expected VAE results would that good: you’ll probably get blurred stuff like this one

so go for GAN but beware that training them properly is definitely not easy


text:
Use ConvNet to predict bitmap
I want to build a classifier which takes an aerial image and outputs a bitmap. The bitmap is supposed to be 1 at every pixel where the aerial image has water. For this process I want to use a ConvNet but I am unsure about the output layer. I identified two approaches:

Have an output layer with exactly 2 nodes which specify wether or not the center pixel of the aerial image corresponds to water or not.
Have an output layer with one node for every pixel. So for a 64x64 image I would have 4096 nodes.

What approach would be preferred and why?
Another thing that is unclear to me is how to get the actual bitmap with only zeros and ones from the output of the ConvNet. Assuming we used a approach 2 then for each pixel our ConvNet would give us a probability between 0 and 1 that the this pixel corresponds to water. How do I decide that this probability is high enough to set the value in my bitmap to 1? Do I just define a threshold, say 0.5, and if the value exceeds that threshold I set the pixel to 1 or is there a more sophisticated approach?

Your first approach doesn't make any sense to me. After all, you are not just interested in the centre pixel are you? And if you have two nodes for every pixel, what are those two nodes encoding? For the probability of water you just need one.
So clearly approach two. I would just use 0.5 as cutoff. Using a higher or lower cutoff only makes sense, if either false positives or false negatives are for some reason more problematic. Using some additional heuristic to adjust the given probabilities would just do what the ConvNet should already have done.
If 4096 output nodes is too expensive you can always make it a bit fuzzier, for example by predicting the probability that at least one of four pixels shows water, reducing the number of nodes to 1024.

Thanks! Yes, approach 1 seems a bit unusual to me as well but I saw it in an example that does something similar to what I want to do so I thought it might be a valid option. In that example they wanted to predict ways and had labels either [1,0] or [0,1], encoding wether the image contains a way in the center or not, respectively.


text:
Which is the most successful AI project so far?
I'm looking for good examples of successful AI projects and theories that had a relatively good impact on society, economics and military field.
So many years have passed after the first AI researches; hence I'm wondering if it has really increased the quality of our lives.

You are supposing that there is a consensus on the definition of AI. But I am not aware of such a consensus. The "AI" locution means a lot of different things and has several incompatible meanings.

@BasileStarynkevitch Could you suggest me a better term so I can edit the question? With AI I didn't ment something specific but anything (software, abstract models, ...) that has a good heuristical outcome related to its environment.

No, I cannot. AI means really a lot of very different things, even from the point of view of recognized AI experts. IMHO, that is ok.

AI means really a lot of very different things, even from the point of view of recognized AI experts. I've got a PhD in AI (1990, symbolic AI). I went a few days ago at an interesting public audition on AI at the French Senate with leading French AI experts (from Google, to some CTO of startups, and our top-class AI scientists from universities, CNRS, INRIA) and there is a consensus that AI does not have any precise meaning today (also in recent US reports)

@BasileStarynkevitch I absolutely agree with you. There are different ways to define intelligence and that fact implies different definitions of AI.

There are so many projects that are successful and those that are still in research.Since artificial intelligence is kind of broad with various fields and where application in such fields vary,I would say there is no which is most.And lastly; those answers have failed to answer the question;they have many projects.as though they have not gained or understood the question! lets understand the question,please! Which is the most succesful AI project so far?

I'd say the most successful are the ones so commonly used that we don't even notice them:

The mail systems that automatically decipher handwritten addresses on your packages, they use machine vision and have probably been doing it since mid-90s.
Algorithmic trading bots on stock markets - they handle something like 85% of all trades.
Many modern CPUs use AI techniques, including neural networks, to guess what your program is going to do next and optimize branch prediction and memory fetches.
Most good modern fraud and spam detectors use some combination of AI techniques (clustering, decision trees, SVMs, even some machine vision to check out attached pictures) - and, in the opposing BlackHat camp, the latest automatic CAPTCHA breakers use all the latest advancements in deep learning too).
And of course there's Google, Facebook and US DoD who try to put AI into anything they can think of.

Are you so sure of the third point (OS using AI techniques)? AFAIK, branch prediction & memory fetches are mostly done by the processor (and indeed several processors & their makers claim to use AI techniques). For example, do you know, for some Linux distribution, an OS level component (in the kernel or elsewhere) using neural networks or machine learning techniques? Can you name it and give a reference?

I meant CPUs, of course, I had in mind things like AMD Ryzen and Exynos M1
Not sure why I typed OS...

There are lots of great projects in AI.

Self-driving cars: This types of cars use AI to learn the pattern of the roads, speed of car, motion of car, braking power and lots of different features and after sufficient learning, they are capable of driving the car autonomously. The best example of this type of cars is Tesla's self driving car.
Games: Games also use AI to learn the game with the aim of winning the game when played against a human or an AI player. You must have played lots of games on mobile and PC like Chess, Tic-Tac-Toe, etc. You play against the computer and according to the difficulty value set, the computer plays its moves. This difficulty value is nothing but the ability of the AI engine to predict the next moves by the opponent.
Chatbots: There have been lots of development and improvements in Chatbots, so that humans can communicate with them as if they are talking to other human. There are many chatbots designed which answer any question asked by us (of course it is dependent on how much intelligence the bot holds). Some examples are ALICE bot, IBM Watson (which has been the most advanced bot till now).
Expert Systems: Expert systems are those systems which focus on one specific domain and can solve any query related to that domain which is given to it. For example, an expert system can be designed to solve any mathematical equation queried to it. An expert system, in such case, will give the solution of the equation along with the steps (providing steps is important because it is an important component in expert system which is called inference engine).
Prediction systems: There are lots of prediction systems which use AI and Machine Learning to predict something based on some past data. Examples are Weather Forecast system, Stock Market prediction system, Recommendation system (usually available in e-commerce websites like Amazon), etc.

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


text:
Would linked Watson supercomputers be even "smarter" than one Watson?
If you had a web of linked Watson-level super-computers, would they be more effective at problem-solving than a single Watson computer alone?
For example, if you asked the Watson-web to diagnose a person's as-yet-undiagnosed disease, would the web be able to do so more quickly?

I guess that they would be only marginally better. And be aware that Watson itself is already a cluster of (quite big) computers (citing Wikipedia):

Watson employs a cluster of ninety IBM Power 750 servers, each of which uses a 3.5 GHz POWER7 eight-core processor, with four threads per core. In total, the system has 2,880 POWER7 processor threads and 16 terabytes of RAM

Because of the rules of Jeopardy, Watson was not allowed to use the Web during the game. At some very high level, it contains a digested cache of some of the Web contents. Giving access to the Internet would improve slightly Watson's performance, but not that much.

if you asked the Watson-web to diagnose a person's as-yet-undiagnosed disease, would the web be able to do so more quickly?

Even if by "web" you mean a more powerful cluster accessing the entire Internet, I don't think that it would answer much more quickly & accurately.
AI is a diversity of sub-domains, and is not advancing as dramatically as some believe. It follows a gradual progression, with in some limited fields (playing Go, or Jeopardy) some spectacular progresses. See also Everything but the essential blog entry by J.Pitrat.


text:
How close are we to having an AI that can play Magic: The Gathering objectively well?
With tools like open AI will we be able to teach an AI to build its own decks? build a deck from a limited pool? or draft? evaluate the power level of a card?

I believe that Steam sells a game for MtG where you can compete against AIs of different levels (hidden inside of a storyline of challenging masters).

That AI can play yes, but that AI can't draft

You're right. I had misread your question. Thanks!

This is a very specific task, with clearly defined parameters, so it would already theoretically be within the scope of current AI technology to do this.
The AI would need to learn how to make decisions, and the best way to do this is the approach taken to teaching an AI to play Go - seeing thousands of example games by experts, and playing itself thousands of times.
The AI won't necessarily "understand" what a card represents, the way a human would, but it can learn to make the same kinds of decisions as the human would.
The difficulties would be purely practical - Go is very easy to represent digitally, because the options for action are limited to placing a stone on one of the intersections, and there is only one opponent. Magic is more complex, so the developers would need to spend sufficient resources to be quite sure they had captured all the relevant variables in the digital representation. Then, of course, they would need to encode thousands of games of Magic (or deck-building processes) into that digital format, so the AI could study them.


text:
Would a neuromorphic SNN of the same complexity as the human nervous system be 'smarter'?
If the nervous system is wired up such that there are no well defined layers, how does this compare to a neatly stacked artificial net? If between my sensory and motor side I had a neatly designed SNN with well defined layers, how would I see the world?
I get that there are some evolutionary advantages to a system where information can sometimes take a shortcut from sensory cell to motor cell (reflex action) bypassing brain processing but for arguments sake let's talk only about intelligence.

The human nervous system is an extremely dynamic entity, having been formed by the processes of embryogenesis, mediated by various markers guiding neurons to grow to specific areas, and all of it laid down by millions of years of evolution. There are many different varieties of neurons in the human brain, indeed more so than pretty much any other animal on this planet.
It is hard to see that a spiking neural network (SNN) would be able to get all these details correct when we don't yet fully understand the biological analog.
I think for this to be successful, we need to understand much more about not only the variety of neurons in the brain, but details of the the embryogenic dynamics as well. And not just the neurons, but the glial cells as well.
Having said that, there is something to be said for using evolutionary approaches to resolve "a solution" that may work anyway. Taking this approach will require many more resources, but is perhaps doable.
All in all, I would not expect a naive attempt of the neuromorphic SNN to succeed. There is a lot of complexity involved in what the brain does, and it involves the glial cells to a large degree. Do we understand enough about the role of glial cells in the brain? We cannot ignore them. Are they only performing "housekeeping" operations, like, for example, the uptake of "spent" neurotransmitters? Or are they doing more, taking part in the computational and / or memory aspects of the brain?
There is much research in this and other pertinent areas that one should look into. And expect a lot of surprises.


text:
Is it a valid assumption that a purely MLP based tic-tac-toe player will learn lookahead strategies?
I'm doing a little tic-tac-toe project to learn neural networks and machine learning (beginner level). I've written a MLP based program that plays with other search based programs and trains with the data generated from the games.
The training and evaluation are strictly policy based - Inputs are board positions and outputs are one-hot encoded array that represents the recommended move for that board position. I've not added search algorithms so that I can understand what to expect from a purely MLP approach.
The MLP model has 35 features and 1 hidden layer and after a few hundred thousands games it has sort of learned to draw 50% games. It has learned the basic stuff like how to block the player from winning and some good board placements.
Now, my question is - It hasn't learned advanced strategies that require making a move that may not be as beneficial for the current move but will improve its chances later. But should I expect that from a strictly policy MLP based no-search approach? Since all that it is being trained on is one board and the next recommended move (even if thousands of those pairs), is it logical to expect it to learn a lookahead approach that goes beyond "the best move for the current board" training?
Put another way, would it be a possible at all for a MLP to learn lookahead without any search strategies? If not, are there any alternatives that can do it without search?

What are those 35 features? And where do you get the recommended move from?

35 is the number of neurons in the hidden layer (or feature maps in the convolution version). The recommended moves are the moves made by the winners of games in the training data. The idea being that it tries to figure out what the winner of the games did and extracts patterns and strategies by itself.

But we are talking about tictactoe: 3x3 board and 0 and X moves?

Yes, that's the one. It's an overkill but I'm using it to understand how neural networks work.

You should probably avoid spatial pooling if you use a convnet, because it might throw away the exact position of the Xs and 0s. Also, if your maps are 3x3, that's already the full board, they'll have to be smaller.

A MLP only does pattern recognition, it will not learn search.
Tictactoe, (Oughts and Crosses), is such a simple game that your network should learn the moves from the training data by heart, no generalisation required. If it still loses games, maybe your training data doesn't consist of particularly good moves.

Thanks. Would be able to extract good moves out of a mix (let's say training data generated from a random player) if the training data consists of hundreds of thousands moves consisting of both good and bad moves?

It should learn the board positions by heart and learn a probability distribution over the moves made in that position, with the highest probability for the most common move.

So, if you only learn the moves of the winner, that might be enough to extract good moves, if you learn all moves, it will only learn random moves.

Ok, so if it consistently sees bad moves, it'll learn bad moves, makes sense. I've been looking for emergent phenomenon where it learns human like strategies while playing with random players.

I feed in only the winner's moves for training but the winner could be winning by fluke even after making bad moves, that explains it. How does it work in games like chess etc where people say that the AI is coming up with its own strategies and what not?

Yeah, but good moves should win more often after many random games, so it should actually work. Chess programming is completely different, it's mostly about tree search. AlphaGo uses neural networks, but it has been trained using reinforcement learning and it has an additional tree search component.

Cool, thanks for the explanation. This (that MLPs would be able to do nothing more than pattern recognition) is true for all other types of neural networks (convolution, dnn, deep belief etc) as well?

Let us continue this discussion in chat.


text:
Is it possible for an AI to learn how to speak from books as training sets?
I want to know something more about it. Are there any github repo or an open source project?

It is possible
The Recurrent Neural Network architectures help in building efficient NLP algorithms, which can identify semantics and their relations across long pieces of text.
With very minor tuning, they can be made generative too. So, here is an excellent article on RNNs which I highly recommend, which also talks about how an RNN was trained on Shakespere's texts and wrote one itself.

Yes, It is possible. Also, if you are from development background you can use JAVA Sphinx, some AI tools and API's. If you are from testing background you can use JAWS which actually reads the readable properties of HTML tags. Nowadays, there are some pdf readers, document reader softwares available you can have a look at them. You can search for Sphinx related projects but I don't know about the other projects.
Please vote and mark the solution if useful.
Thanks!

It depends whether you include learning to produce sound waves in the task (I'm taking "how to speak" to be different from "how to write" in your question).
If the task is to learn a language, you can certainly learn from written texts, and try a generative approach (usually, after a few sentences, humans can be disappointed though).
If the task includes generating a voice response that is also learnt, then it had better hear some spoken language too. Of course, you can bypass the task of learning how to generate sound by plugging a standard text to voice module after your generator.

Ya Sure it is possible. It wont be efficient as human speech though (At least not yet). It all depends on how you use your data. If you use your data efficient enough, then you could be the one creating an AI which closely resembles human speech. Your idea is good. You would need help from a GPU for processor all that complex text processing. I hope I was at least a little of help. I unfortunately don't know about any open source projects.


text:
How many training example text classifier needs to be trained?
I want to train text classifier (using https://www.uclassify.com) with 12 classes/categories. I will be training it to classify news/articles (I know that there are existing classifier but I want to train my own).
uclassify uses following algorithm (directly copied from their site):

The core is a multinominal Naive Bayesian classifier with a couple of
  steps that improves the classification further (hybrid complementary
  NB, class normalization and special smoothing). The result of
  classifications are probabilities [0-1] of a document belonging to
  each class. This is very useful if you want to set a threshold for
  classifications. E.g. all classifications over 90% is considered spam.
  Using this model also makes it very scalable in terms of CPU time for
  classification/training.

I was wondering how many examples I will need to train such classifier? It is possible to estimate the number? Let's assume that one article will "fit" 2 categories by average.

As a general rule of thumb I typically use 10*(# of features) for shallow machine learning models such as Naive Bayes with only 2 classes.
So it all depends on the number of features you will be using. However, the more output classes the more data you will need for proper discrimination. The addition of more classes is not linear but I think you can get away with: 10*(# of features)*(# of output classes)


text:
Can we apply ANN to cryptography?
If a group of computers have identical ANN with exact same set of learning data and all have functionality of encryption and decryption, would there be any way for interceptors to interpret encrypted data?
+
Applying the fact that people with more background information obtaining more knowledge from same source than those who don't, would it be possible for ANN to interpret data based on their access level?
(Each level has different amount of "background information")
For example, if there is a encrypted text file, a computer with highest access level would fully decrypt the data to a plain text while a computer with lower access level would only decrypt half of them (and this decrypted half becomes a plain text).
If above methods can exist, what would be their pros and cons compared to pre-existing technologies? (AES, Blowfish and so on)

I know that in order to discuss your question, I must have a background in cryptography, which I don't have! But there is something that I know for sure:

First of all, a simple search gave me this. It might help.
To lots of us, ANN looks like a magic wand which can turn almost everything into anything. But the point is, ANN is only a ML algorithm, but absolutely a powerful one. You should be aware that there are random and multiple weight initializations in ANNs, and this means a fairly stochastic behavior of your network, which vanishes only in shallow networks with high amount of training data. Your network's specifications are even likely influenced by the order of feeding the instances in the training phase. So if what I think of the encryption/decryption process "certain rules for message transformation" is true, then a stochastic network is indeed a sophisticated option (but according to scientists in neural cryptography research area, completely possible)
You're probably thinking of auto-encoding networks, one kind that maps X to X and has a bottle neck, such that if successfully trained, it has developed the power of reducing the number of data features from say 10'000 to 500, and then successfully retrieving the original data with 10'000 features from that 500-features one; such that If I feed a new instance to a trained auto-encoding network, grab it in the bottle neck layer and send it to you, you must be able to feed the message to the bottle neck layer and receive the full decoded message from the output layer. However there's (always) a catch! and that is you need a really "BIG" dataset to train your deep network. Besides you cannot expect it to work well on every kind of data after being trained by a fixed amount. for example your network cannot successfully retrieve an image of a dog, if all you've fed in the training phase was cats' and lizards' images. So can you guarantee that new messages to be encoded have the same type as the ones in the training set?! If no, then you might also take this challenge into account.


text:
Does this "flavor" of AI have a name?
In order to build a Scientific Reference Parser, I am contemplating a kind of "AI" system, and would like to know if something similar is already an established "design pattern" in AI research.
The input for the system would be Scientific References with structures like the following:
"Co-authors, title, Journal, volume, issue, begin page, year"
Of course, many other variations are possible, and I want to build a system that can make "best guesses" in case of unfamiliar patterns.
At the moment this is done by manually chaining the results of different methods together, ranging from Regex patterns to more complex algorithms like N-Grams, LSH and random forests. I contemplate a AI system that automatically "chains" all these methods together in the most optimal way. The way I imagine this to work is by means of what I call "a bag of functions". So, how would this work?

For each of the methods I use at the moment, I would specify their input requirements, and specify what they provide as output. (e.g.: input = reference, output = title). These could also be parameters like: input = year, output = is valid year? . Note that if a function outputs "title" that is an attempt at providing the title, but this is not necessarily correct (if for example, the regex pattern grabbed a wrong portion of text).
For each of these functions, I would build a training set, and log their execution time (cost) and their probability of providing a correct result.
Then, I would build a system that chains these functions together to get from a certain input, to a certain output. eg: from -a function that takes a reference, and outputs the list of co authors- to -a function that takes a list of co authors, and breaks it apart into separate authors- to -a function that takes an author, and tries to break it apart into last name and initial-.
Once a "chain" of functions is found, this chain can in turn be stored as a "function" and can be reused later on by the algorithm. For each function, the success rate and run time is stored, so the algorithm can choose to go for the fastest known route, or experiment with new functions.
In the settings you could specify the max run time (cost) or the minimum success rate. This way you could push the system to experiment with new combinations of functions.

I'm not sure I explained the intent clearly, and I'm not sure the design would hold once I try to implement this in reality. Just wanted to throw this out here to see if anyone recognizes the design. This feels like a combination of a shortest path algorithm (to connect the functions) with normal statistical probability (to determine the success rate of a function) with a "self learning" system (because combinations of functions can be "remembered" and reused).
The added advantage would be that I don't need to manually guess what parsing method I should give a higher or lower likelihood of being correct in what specific scenario. It would allow me to just "throw" a new function into the bag, and let the system test it in all kinds of configurations, learning when best to use it, and when to avoid it.
Any feedback would be greatly appreciated! :)

This sounds a little bit like a Blackboard Architecture approach.  One of the biggest challenges in these is figuring out how to handle coordination between the various "experts" (ie, algorithms).  Some people talk about an "executive" which manages the coordination, and that leaves you needing to figure out how to train the "executive".  Alternatively, you may be able to do this without a master "executive", but nobody knows exactly what the best way to do this is.
You may also find some inspiration / useful ideas in the realm of Multi-agent Systems if you model each component of your systems as a discrete "agent".


text:
How should dropout change with network depth?
I know I've seen this somewhere before, but can't find it now.  Say we have a neural network with a handful of layers, and we're applying dropout to each layer.  As we move closer to the output, should dropout decrease, increase, or stay the same?

We can think of the dropout as of averaging over many networks. Not as a way to mute or denoise your data. Therefore the rule of thumb is the dropout should be applied to higher layers in your network. It is usually applied to fully connected layers (if at all!). It is a common practice to keep 0.5-0.75. neurons active. Personally I prefer L2 much more.

So dropout should decrease as we get closer to the output.  Why do you prefer L2?

It seems to be more stable in general.
When you have a large pretrained network and you want to keep the architecture unchanged and you want to use it to work with a smaller amount of data - I've empirically found that with little data you can apply strong L2 regularization with v. good effects (to fc layers - not to conv layers). The same doesn't apply to dropout. Keeping less than 0.5 neurons may result in v. unstable training.

OK thanks. Do you know if it's beneficial to have dropout on more than one layer, or is one usually good enough?

Related question: is it best to use L2 on just 1 layer or all fully_connected?

I don't think I've ever thought of applying l2 to only some of fc layers. Although, since you seem like looking for a general advice I would suggest getting the architecture right without focusing on the details too much, and getting to know your architecture through experimenting (on the large changes first, keep it simple).


text:
What linear rectifier is better?
What rectifier is better in general case of Convolutional Neural Network and how about empirical rules to use each type?

ReLU
PReLU
RReLU
ELU
Leacky ReLU

FYI Comprehensive list of activation functions in neural networks with pros/cons

I've read all the papers about PReLU, LeakyReLU (...) and all the claims how it improves this and that but the little dirty secret is: most of the time it doesn't matter at all and you can't go much wrong with ReLU - empirically proven. I've personally tried all of them in many different problems (from training small networks from scratch through changing activations in large pretrained models) My guess is that gradient doesn't die much in any of them and the rest is pretty much irrelevant.


text:
Training a convolutional network to recognize object location
I am beginning an image analysis project to recognize images with a particular object centered on the image. If the object is at the center, I give the image a positive label, and if it is anywhere else, or simply not in the image, I give the image a negative label. The object, itself, has a complex pattern, such that statistical methods and basic image processing techniques are not able to detect it. The human eye, however, has no trouble detecting this object. Therefore, I am opting to develop a convolutional network that can parse the complexity of this pattern. The only issue, however, is that convolutional networks are inherently designed to be spatially invariant. Therefore, is it even possible to train the network to focus on the importance of the object being at the center simply by feeding the network many negative examples containing the object anywhere else but the center? Furthermore, is there perhaps a better or more direct way to go about incorporating this spatial aspect into the network's functionality?

Just feed only the center of the image into your CNN.

Not a bad thought, but that unfortunately will not work for my purposes since this particular object exists relative to its surrounding environment.  The object is essentially a column of grouped together dots that shows up relative to background dots surrounding the object.  If there are many background dots, then a zoomed in window might confuse background information for a column of clustered dots.  In other words, it's the sudden increase in dot number, synchronized in a vertical fashion, that I am attempting to recognize.

Ok, you can always just use a normal NN instead of a CNN, but this problem sounds like it might be solvable with a special purpose algorithm.

To use a convolutional net that isn't spatially invariant, you can make the convolution matrix of size equal to your input image size. Afterwards, just use any desired number of fully connected layers and your network should be able to learn your dataset.

I like this idea, but what if I wanted to still retain some degree of spatial invariance in the y-axis direction.  For this, I could add a kernel that parses the image's full size in addition to the standard ones that translate over the image.  I think that would work quite well.


text:
1 hidden layer with 1000 neurons vs. 10 hidden layers with 100 neurons
These types of questions may be problem-dependent, but I have tried to find research that addresses the question whether the number of hidden layers and their size (number of neurons in each layer) really matter or not.
So my question is, does it really matter if we for example have 1 large hidden layer of 1000 neurons vs. 10 hidden layers with 100 neurons each?

Basically, having multiple layers (aka a deep network) makes your network more eager to recognize certain aspects of input data. For example, if you have the details of a house (size, lawn size, location etc.) as input and want to predict the price. The first layer may predict:

Big area, higher price
Small amount of bedrooms, lower price

The second layer might conclude:

Big area + small amount of bedrooms = large bedrooms = +- effect

Yes, one layer can also 'detect' the stats, however it will require more neurons as it cannot rely on other neurons to do 'parts' of the total calculation required to detect that stat.
Check out this answer

Thank you so much for your answer. Just to clarify, when you write "it makes your network [...]", are you referring to the case when I have many hidden layers with fewer neurons each rather than having more neurons in fewer layers?

@StephenJohnson oops, I edited the question. I'm referring to the deep network (multiple layers).

Nice answer, thanks again. Maybe I should continue this in another thread, but do you think the same kind of reasoning applies to recurrent neural networks such as GRU or LSTM?

@StephenJohnson do you mean one layered recurrent networks vs multilayered recurrent networks or do you mean because of their recurrent connections?

I mean generally, because of they have recurrent connections allowing them to map contexts over longer distances, do such networks benefit from being Deep in the same way a regular feedforward network would? Maybe they can't be compared like that since recurrent networks typically are used when sequential data, such as audio, is used.

@StephenJohnson i'm not sure. I just googled "Deep RNN's" and nothing interesting popped up. A reason for this is that RNN's tend to come with predefined architectures (LSTM, GRU, NARX, etc.). And exactly as you say: they are focused on sequential data. But there is one thing: some LSTM's for example have one layer of 5 blocks, and another layer of 5 blocks. So basically deep RNN's can find abstract relationships between memory blocks better than single layered RNN's :)

Let us continue this discussion in chat.

AFAIK in DNN, the interesting fact is that a hierachy of the knowldge is built throw layers. Bottom layer learn basic concepts and upper one higher concepts. With one layer of 1K neurons, you will mainly construct a kind of loop-up table. With a DNN hierarchy of concepts with is much powerful than the previous NN. But his rely on the assumption that the world is like that: high level concepts are build upon basic one.

There are so many aspects.
1. Training:
Training deep nets is a hard job due to the vanishing (rearly exploding) gradient problem. So building a 10x100 neural-net is not recommended.
2. Trained network performance:

Information loss:
The classical usage of neural nets is the classification problem. Which means we want to get some well defined information from the data. (Ex. Is there a face in the picture or not.)
So usually classification problem has a lot of input, and few output, whats more the size of the hidden layers are descend from input to output.
However, we loss information using less neurons layer by layer. (Ie. We cannot reproduce the original image based on the fact that is there a face on it or no.) So you must know that you loss information using 100 neurons if the size of the input is (lets say) 1000.
Information complexity: However the deeper nets (as Tomas W mentioned) can fetch more complex information from the input data. Inspite of this its not recommended to use 10 fully connected layers. Its recommended to use convolutional/relu/maxpooling or other type of layers. Firest layers can compress the some essential part of the inputs. (Ex is there any line in a specific part of the picture) Second layers can say: There is a specific shape in this place in the picture. Etc etc.

So deeper nets are more "clever" but 10x100 net structure is a good choice.

If the problem you are solving is linearly separable, one layer of 1000 neurons can do better job than 10 layers with each of 100 neurons.
If the problem is non linear and not convex, then you need deep neural nets.

If the problem is linearly separable you don't need hidden layers at all

I think you have a confusion in the basics of the neural networks.
  Every layer has a separate activation function and input/output
  connection weights.

The output of the first hidden layer will be multiplied by a weight, processed by an activation function in the next layer and so on.
Single layer neural networks are very limited for simple tasks, deeper NN can perform far better than a single layer.
However, do not use more than layer if your application is not fairly complex. In conclusion, 100 neurons layer does not mean better neural network than 10 layers x 10 neurons but 10 layers are something imaginary unless you are doing deep learning. start with 10 neurons in the hidden layer and try to add layers or add more neurons to the same layer to see the difference. learning with more layers will be easier but more training time is required.


text:
How do neural networks manage to do regression?
I'm trying to learn about neural networks, and I'm interested in gaining a better conceptual understanding of how they work to solve certain problems. I'm having trouble in conceptually understanding how they succeed in doing regression (i.e. predicting continuous variables), however, and wondered if anybody has a good explanation. I know the mathematics of how NNs work, but a clearer conceptual understanding would be helpful.
To give an idea of what I mean by a "conceptual understanding", here's the one that I have for how multilayer NN's with a sigmoid activation function are able to be effective classifiers. Each NN takes the scalar product of its inputs and a set of weights. The weights define a plane in the input space, and the sign of the scalar product indicates which side of the plane the point defined by the inputs is on. The sigmoid activation function outputs 1 if the point is on one side and 0 or -1 (depending on which function is used) if the point is on the other. So the first hidden layer of neurons can be considered to identify which side of each of a group of planes the input point is on. The neurons can also act as AND and OR gates, so subsequent layers of neurons give an output indicating whether the point lies in a region bounded by several of the planes (e.g. a neuron activates only if the point is above one plane and below another, indicating it is in a region of the space associated with one class of points). So if the network learns an appropriate set of planes to bound regions containing different classes of inputs and the AND/OR relations that determine whether a point is in a given region, then it can classify the input points, and this can work for regions with arbitrarily shaped boundaries.
I've not found or been able to think of a similar way of explaining why an NN can perform well in general regression problems (if it's big enough). Does anyone here know a way to explain this?

I came across the article A visual proof that neural nets can compute any function that explains how a neural network can approximate any function, which pretty much answers my question.
I suppose connections between neurons do not generally arrange themselves in the way described, though, so it would still be interesting to get insight into whether there are patterns of how the inter-neuron connections arrange themselves in neural networks trained to solve actual problems.


text:
Multi-label Classification with non-binary outputs
I am looking to train a dataset that would output a sequence of letters (I'm using this for peptide sequences). Since I have 22 different possibilities of amino acids, I need to output a vector that contains multiple amino acids with varying frequencies. For example, an output would look like [0,1,3,2,0,2,0,3...] (a 22-long vector).
How can I train a neural network to output that type of vector?

What exactly does your output relate to? I don't understand what 3 or 2 is in your output, could you explain?

@ThomasW Since each peptide sequence has multiple amino acids of the same time, a 3 could represent 3 Ws. For example let's say my peptide sequence is WYTWXTGW, my output vector would have to account for the frequency of each amino acid.

this doesn't make sense. If you output the frequency of letters, then how do you know the actual sequence? And more importantly, what is your input for this output?

Sorry for the confusion, but the actual sequence is part of the labeled dataset. This is a supervised problem. The input is spectra data that is labeled with a peptide sequence (and thus its corresponding amino acids). The actual data is represented in terms of m/z (a numerical number for spectra data). So if the number is (hypothetically) 4321.32, the peptide sequence could be WYTWXTGW. I want to train a neural network that takes in this information so when it is presented with unlabeled spectra data (after training), it can provide the peptide sequence.

Oke, the second part helped me understand the problem. If I manage to think of an answer I'll post it. But, I still don't understand the first part. Let's say you only have 2 different aminoacids: A and B. So output would be [x, y]. Say you have output [2,1]. How would you know if the sequence is AAB, ABA or BAA? That's my problem  with this :) - i'm not a biological expert, but there are different peptide sequences with the same amount of certain amino acids, right?

Yes you are correct. There is no real way for me to tell the order after the the network is trained by I hope to just output the frequency for now :) . You are also correct that there are different sequences with the same amount of certain amino acids.

Please, edit this post to ask an actual clear question.

Technically, you're not really doing classification The outputs you have are not labels, they are real values. So I've got two (possible!) solutions, and you'll have to test them out for yourself:
Solution 1
Because each output is actually a numerical value, you can normalize them just like you would normalize all other numerical values. So you choose a maximum value that you would expect for the labels (you can also do this per label), and divide the actual value by that value to normalize it.
So if you don't expect more than 10 of the same amino acids in each peptide sequence, then you divide all amounts by 10:
0 becomes 0.0
1 becomes 0.1
2 becomes 0.2
3 becomes 0.3
etc.

Solution 2
This is more complex, but if you'd give it a try it would surely work. This solution requires recurrent networks. Just like LSTM networks are good for character-by-character text prediction, they will work for your 'peptide sequence language' as well.
This solution also allows an output sequence of any length.
How it works? You have a network with óne output (m/z), and 22 outputs (one-hot encoded amino acids) + 1 more, when this output has the highest value it tells you that the sequence has finished.
You keep on inputting the same value of m/z, until your network tells that the sequence has finished. The network will output different letters every activation based on the previous outputs (the LSTM model has some kind of memory).
This solution is kind of hard to explain, but if you provide me with a small list of peptide sequences (not too long, and not too much), then i'll make a working online example of you.

As promised, I made simple implementation of solution 2. However, I think you should go for solution 1 anyways. I didn't have any real data, so my model is basically overfitting, but it basically works: https://jsfiddle.net/ovpkL2xx/2/ (might take some time to run)
Made with Neataptic

thank you so much! I'll follow your advice. Unfortunately, I cannot provide you with any data due to patient confidentiality. I'll see if I can find any public examples.

@rajkarthikkumar I understand, just any simple peptide sequences and their m/z value is enough. (also provide all the different amino acids letters)

http://www.fao.org/docrep/004/y2775e/y2775e0e.htm (all the one-letter codes for the amino acids)

@rajkarthikkumar that will do, I'll just make some sequences and their m/z values up

@rajkarthikkumar I tried solution #2, unfortunately it is very hard to get a good error as my 'made up data' doesn't really have any correlations. So I'm going to try solution #1 somewhere soon, should work better

I found a website with public spectra data. http://www.massbank.jp/QuickSearch.html If you search up, for example, Tyrosine, you get a list of example spectra http://www.massbank.jp/jsp/Dispatcher.jsp?type=disp&id=KO002701&site=0

Do you mind if you send me your implementation of the LSTM? I'm struggling to see how to piece it together.

Sorry! I started on it but it got out of my head. Ill send something tomorrow !

@rajkarthikkumar updated the question


text:
how fast does need to be an AI agent to be efficient?
I know nowadays agencies are using GPUs in order to accelerate AI, but how fast should be it to be efficient, I mean I know that depends of how large and complex the assignment is but what would be a way to measure its efficiency and what kind of technology(amount of GPUS,RAM,STORAGE) and techniques need to be used in order to get enough efficency?
Any thoughts from experts would be appreciated

Glad that was helpful.  If you haven't previously come across them, you will find the concepts of bounded rationality and automata theory quite useful.

I asked a sort of similar question a while ago, related to DeepBlue and AlphaGo, but hardware and volume limitations don't seem to be very much emphasized currently.

Wow..Now I got a lot to read and process. Thanks a lot for all of the information , you shared more than expected

This got me thinking about the architecture of self-driving cars (how they have to be fully autonomous i.e. can't rely on network connection) and I found a lot of links to the Nvidia Drive PX-series which the manufacturer categorizes as a supercomputer

My understanding of efficiency in this context is in regards to optimization of algorithms as opposed to hardware speed, which is more of a "brute force" component.  GPUs may be more energy efficient, but this is distinct from linear optimization of algorithms.
In terms of how much processor speed you need to tackle a given problem, that's in the realm of computational complexity theory and analysis of algorithms.
Amount of GPUs, RAM and storage needed to tackle a given problem are purely a function of the complexity of the problem and the efficiency of the algorithms.


text:
Tagging parts of speech when proper noun is a composite
By means of parts of speech tagging, words of a given sentence can be assumed to be noun/verb etc, but if the sentence is for instance:
"My favourite book is harry potter and the prizoner of azkaban"

note that the inputs I receive would be from a chat interface so having a fixed format for the data can't be expected. Is there a way to identify "harry potter and the prizoner of azkaban" as a proper noun from such messages?
Currently this query tags as:
My|PRP$
favourite|JJ
book|NN
is|VBZ
harry|JJ
potter|NN
and|CC
the|DT
prizoner|NN
of|IN
azkaban|NN

I would like to know if this can be handled some way, or if there is another algorithm that can handle this?

I guess your problem is a form of NER (Named-Entity Recognition) tagging. NER tags consist of PER(person), LOC(location), ORG(organization) and MISC(miscellaneous) and O(other). with the help of a NER-tagger algorithm, you probably would have:
My(O) favorite(O) book(O) is(O) harry(B-MISC) potter(I-MISC) and(I-MISC) the(I-MISC) prisoner(I-MISC) of(I-MISC) azkaban(I-MISC).
now you can tokenize your text with identifying different NER tags, and join "B-" and "I-" prefixes with the same NER tag. e.g. you have "harry potter and ..." as a single token, which is a MISC and starts from harry (since harry is B-MISC) and ends to azkaban (since azkaban has the last consecutive I-MISC tag). Now you can let your POS tagger act the "harry potter ..." as a single token, and it must tag it with "NN"
Another solution for this problem is called "chunking". It works based on a set of rules and detect Noun Phrases (NPs). Here, you define a rule and create the regexp statement for it. e.g. you define all consecutive NNs as a single NP (harry potter): <NN>+ or a DT followed by a string of NNs (the brown fox): <DT>?<NN>+. Now you tokenize your text based on a regexp matching method. but in your case, chunking such a long NP is almost impossible. because a rule that finds this NP as a NP candidate, would by mistake find a lot of other string of words as a NP candidate too, while they're not a NP at all. (see nltk: information extraction)


text:
How to "combine" two images for CNN input (classification task)?
For a classification task (I'm showing a pair of exactly two images to a CNN that should answer with 0 -> fake pair or 1 -> real pair) I am struggling to figure out how to design the input.
At the moment the network's architecture looks like this:
image-1                       image-2
   |                             |
conv layer                    conv layer
   |                             |
   _______________ _______________
                  |
            flattened vector
                  |
          fully-connected layer
                  |
           reshape to 2D image
                  |
              conv layer
                  |
              conv layer
                  |
              conv layer
                  |
            flattened vector
                  |
                output

The conv layers have a 2x2 stride, thus halfing the images' dimensions. I would have used the first fully-connected layer as the first layer, but then the size of it doesn't fit in my GPU's VRAM. Thus, I have the first conv layers halfing the size of the images first, then combining the information with a fully-connected layer and then doing the actual classification with conv layers for the combined image information.
My very first idea was to simply add the information up, like (image-1 + image-2) / 2...but this is not a good idea, since it heavily mixes up image information.
The next try was to concatenate the images to have one single image of size 400x100 instead of two 200x100 images. However, the results of this approach were quite unstable. I think because in the center of the big, concatenated image convolutions would convolve information of both images (right border of image-1 / left border of image-2), which again mixes up image information in not really senseful way.
My last approach was the current architecture, simply leaving the combination of image-1 and image-2 up to one fully-connected layer. This works - kind of (the results show a nice convergence, but could be better).
What is a reasonable, "state-of-the-art" way to combine two images for a CNN's input?
I clearly can not simply increase the batch size and fit the images there, since the pairs are related to each other and this relationship would get lost if I simply feed just one image at a time and increase the batch size.

Could you give more information on what makes a "real pair" and a "fake pair"?

I've implemented a GAN. Should've mentioned that earlier. Fake pair is a generated sample, real pair is training images.

To be specific, I'm trying to implement my own version of this: https://phillipi.github.io/pix2pix/

the only thing I could think of is passing both images through a whole set of convolutional layers and pooling layers on their own (independently), and then combining them with a fully connected layer at the end of the network.

@ThomasW I have only tested one setup so far with two completely different sets/streams of conv layers for the two images and the "late fusion", but this one test did perform worse.

My latest approach is to simply concat the feature maps after the first separated conv layers, i.e. concatenating 32 feature maps for image-1 with 32 feature maps for image-2 to get one large set of 64 feature maps and then pass them to the subsequent layers. Still rather unstable, but best performance so far.

You can combine the image output using concatenation. Please refer to this paper:
http://ivpl.eecs.northwestern.edu/sites/default/files/07444187.pdf
You can have a look at the Figure 2. And if you are using caffe, there is a layer called Concat layer. You can use it for your purpose.
I am not fully clear about what you want to do. But like you said, if you want to pass the image values from the first layer to some layers. Try reading about skip architectures.
If you want to use this network as real/fake finder, you can take the difference between two images and convert it to classification problem.
Hope it helps.

Note that the website linked is under construction. You can still find the paper here: https://web.archive.org/web/20170517022842/http://ivpl.eecs.northwestern.edu/sites/default/files/07444187.pdf

I'm not sure what you mean by pairs. But a common pattern for dealing w/ pair-wise ranking is a siamese network:

Where A and B are a a pos, negative pair and then the Feature Generation Block is a CNN architecture which outputs a feature vector for each image (cut off the softmax) and then the network tried to maximise the regression loss between the two images. The two networks share the same parameters and thus in the end you have one model which can accurately disambiguate between a positive or negative pair.

eggie5 actually has a good solution for you. This approach is a tried and tested way to solve the same problem you are trying to solve.
However, if you still want to concatenate the images and do this your way, you should concatenate the images along the channel dimension.
For example, by combining two $200\times 100 \times c$ feature vectors (where c is the number of channels) you should get a single $200\times 100 \times 2c$ feature vector.
The kernels of the next convolution look through all the channels of the feature vector $x \times x$ pixels at a time.
If we combine along the channel dimension, it becomes easier for the network to compare pixel values at corresponding positions in both images. Since the objective is to predict similarity or dissimilarity, this is ideal for us.

Hey, welcome to the site. Could you edit your answer to explain why concatenation should be along this dimension?