text:
Berkeley AI Course Question on Nearly Zero Sum Games
I am drawing this question from Berkeley's AI course (also not sure if it is the correct place to ask, so I apologize ahead of time)
https://inst.eecs.berkeley.edu/~cs188/pacman/course_schedule.html
Currently, I am working on section 3's Homework.
My question is: the question (Part 1, question 6). Why is it that we can only guarantee that if the Min agent acts suboptimally, the best we can hope for is the following
It seems that we can put any arbitrary value for the second node e.g. whey does it have to be -Episolon. It could be any range of values, e.g. Epsilon, in which case we would have optimised the Player A

Try to summarize your research question;please!

The question is very simple - why does A's outcome on the second branch have to be minus epsilon? Couldn't it be any random number?

(using X for epsilon because keyboard)
This is just a hypothesis, but if you have a maximising agent and a minimising agent, then the optimal outcome for A (maximising) is to sweep the board (X,0), while the optimal outcome for B (minimising) is (-X,0) because B is minimising A's score, not their own.
A's optimal outcome is then complicated by the factor for sub-optimality, which we then imagine approaches zero.
There seem to be a bunch of assumptions that are not articulated, though, if this hypothesis is true.


text:
What algorithm should I use to classify documents?
I'd like to build a program that would learn to automatically classify documents. The principle would be that, for each new document I add to the system, it would automatically infer in which category to classify the document. If it doesn't know, I would have to manually enter the category. For each hint I give to the system, the system would learn to refine its knowledge of document kinds. Something similar to face recognition in Picasa, but for documents.
More specifically, the documents would be invoices, and I want to classify them by vendors. Documents could be extracted as text, as image, or both.
Is there some know algorithms for this kind of job?
Up to now, I could think at two possible ways I could do it:

For images, I could add all the images of a given kind together, and record the pixels that are the most common to all images, to create a mask. For a new image, I would compare this mask with the image to determine how similar it is.
For text, I could record the list of words or sentences that are similar to all documents of a given kind.
Finally, I could do a combination of both techniques, for example by converting a PDF document to an image, or an image to text by OCR techniques.

I'm just wondering if I'm approaching the problem the right way. Especially about storing just enough information in the database.

Text approach:
Use LDA (Latent Dirichlet Allocation). LDA is unsupervised. Feed it in corpuses of text from the various documents (i.e. OCR them and feed LDA the results of OCR). It will then cluster them based on the contents of the text (with or without stop words - at your discretion). If possible, you could do a supervised approach of using a bag-of-words and any classifier such as an SVM or Random Forest.
Image Approach:
Use a CNN (convolutional neural network) and train it on images of the various vendors. If you don't have this class discrimination, and can't get it, then use an unsupervised approach such as an autoencoder and then cluster the points in the lower-dimensional autoencoder feature space.

source: Stack Exchange

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

sort: votes


text:
Infer dependent variables to produce output aligned to trained data
Hypothetical example, say I wanted: P(gender,ethnicity|age,hair); so that the input would aligned to a trained dataset of: (gender,ethnicity,age,hair) => hat bought.
What approach is 'best' for computing ~gender and ~ethnicity given age,hair; in order to predict the hat bought?
The processing of the inputs => hat can be done/learned offline whereas infering the missing input values shall be done online. The results of the online pass shouldn't be stored in the network.
FYI: I am considering two Recurrent Neural Networks one for each problem.

Hmm, looks like what I'm talking about is called Imputation

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


text:
Why are deep neural networks and deep learning insufficient to achieve general intelligence?
Everything related to Deep Learning (DL) and deep(er) networks seems "successful", at least progressing very fast, and cultivating the belief that AGI is at reach. This is popular imagination. DL is a tremendous tool to tackle so many problems, including the creation of AGIs. It is not enough, though. A tool is a necessary ingredient, but often insufficient.
Leading figures in the domain are looking elsewhere to make progress. This report/claim gathers links to statements by Yoshua Bengio, Yann LeCun and Geoff Hinton. The report also explains:

The main weaknesses of DL (as I see them) are: reliance on the simplest possible model neurons (“cartoonish” as LeCun calls them); use of ideas from 19th century Statistical Mechanics and Statistics, which are the basis of energy functions and log-likelihood methods; and the combination of these in techniques like backprop and stochastic gradient descent, leading to a very limited regime of application (offline, mostly batched, supervised learning), requiring highly-talented practitioners (aka “Stochastic Graduate Descent”), large amounts of expensive labelled training data and computational power. While great for huge companies who can lure or buy the talent and deploy unlimited resources to gather data and crunch it, DL is simply neither accessible nor useful to the majority of us.

Although interesting and relevant, such kind of explanation does not really address the gist of the problem: What is lacking?
The question seems broad, but it may be by lack of a simple answer. Is there a way to pin-point what DL is lacking for an AGI ?

See also Can machine learning be used to pass the Turing test?.

Everyone dealing with neural networks misses an important point when comparing systems with human like intelligence. A human takes many months to do anything intelligible, let alone being able to solve problems where adult humans can barely manage. That and the size of human brain is enormous compared to our neural networks. Direction might be right, but the scale is way off. Number of neurons in human brain can be matched memory-wise but the amount of parallelism to simulate it real-time cannot yet be achieved (at least for a random researcher). While a little old this might give you an idea of how much we lack the processing power.

Deep Learning is mostly successful in supervised learning, whereas the brain builds categories mostly in an unsupervised way. We don't yet know how to do that. (Take a look at google brain: 16,000 cores and all this thing can do is recognise cats and human faces with pretty abysmal accuracy.)
Deep Learning uses highly unstructured activations, i.e. the high level representations of "dog" and "cat" in a neural network classifier don't have to be similar at all. The brain on the other hand uses inhibitory neurons to create sparse distributed representations which are decomposable into their semantic aspects. That's probably important for abstraction and reasoning by analogy.
The brain has many different parts which work together. Deep Learning researchers are only just beginning to integrate memory or attention mechanisms into their architecture.
The brain integrates information from many different senses. Most Deep Learning applications use just one type of input, like text or pictures.
The brain is capable of modelling sequences as categories. (Basically every verb names a sequential (i.e. temporal) category.) It can then arrange these categories into long-term hierarchical plans. So far I haven't seen anything in that direction in Deep Learning.
Also neural networks can't yet operate on the same scale as the human brain. If you look at the answers to this question, the human brain will be ahead in neuron count for another couple of decades. A neural network might not need the same number of neurons as the brain to reach a similar performance (because of higher accuracy), but right now for example video processing is still pretty limited in terms of input and throughput.

IMHO the first hurdle is scale: even Google's largest DNN doesn't come close to the scale of the brain, and by a factor of several orders of magnitude...

I think it's missing still the aspects what makes a human brain; having a lot of different networks working with each other.
Just like meditation improves cognitive abilities by having the brain work more synergistically, we could apply that to machines too.
For example google is learning a computer to dream, just like we do, to reinforce what we already learned.
https://medium.com/@tannistho/why-is-google-teaching-its-ai-to-dream-e9ae9ecd0e3a#.gljal6pww
And here is pathnet, a network of neural network.
https://medium.com/@thoszymkowiak/deepmind-just-published-a-mind-blowing-paper-pathnet-f72b1ed38d46#.ed0f6pdq7
Creating all these mechanics and putting them all together, with enough power and we will get pretty close!

Could you clarify what "it" is? It could be the process of deep learning, or equally deep networks. These are different.

Both, but mainly having deep neural networks work with each other, I speculate that DNN should also have good neural plasticity features. But this is something we could only touch the basics on, we don't even know even know how exactly a human brain works

Artificial intelligence proponents today are focused on the problem of computability - the ability to solve complex problems fast. It is my belief that any amount of success in this direction will not lead to human (general) intelligence although it certainly will outperform humans in certain domains. Instead, efforts should be toward a study of what neurological events cause sensation (the experience of qualia). Of course, this is the hard problem of philosophy but I believe it is the unique key to general intelligence and its capabilities. Reverse engineering and also testable theories should be advanced toward this end.

Quaila might be an interesting trait for machines to have (especially if we want people to give rights to these machines), but aside from quaila itself being a very hard problem in philosophy, there's two main issues at play. (A) intelligence itself may not require quaila, you can be smart without being  able to have subjective first-person experiences..i.e., the philosophical zombie.

(B) Industry only cares about solving complex problems fast and doesn't really worry about whether said fast machine can think or feel. AGI is only desired to the extent that it could solve a complex problems fast...intelligence is only a means to an end. (In fact, industry may not want a thinking and feeling machine, as such machines may deserve rights...and rights are kinda like regulations, limiting what a business can do with their tool.)

Right. There is a very limited economic potential in machines that think, feel, suffer, want, get angry, etc. You've essentially made a machine that you cannot ethically turn off nor command. Much more useful is modelling the useful parts of intelligence which can perform complex, fast, and limitless computation without creating machines with desires or selfhood.

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


text:
Can an AI be made to maintain a train of thought?
This mostly refers to human-like or chatbot AI, but could maybe be used in other applications (math or something?).
Basically, it occurred to me, that when I'm thinking or speaking, there is a constant feedback loop, in which I am formulating which words to use next, which sentences to form, and which concepts to explore, based on my most recent statements and the flow of the dialogue or monologue. I'm not just responding to outside stimulus but also to myself. In other words, I am usually maintaining a train of thought.
Can AI be made capable of this? If so, has it been demonstrated? And to what extent? While typing this, I discovered the term "thought vectors", and I think it might be related.
If I read correctly, thought vectors have something to do with allowing AI to store or identify the relationships between different concepts; and if I had to guess, I'd say that if an AI lacks a strong understanding of the relationships between concepts, then it would be impossible for it to maintain a coherent train of thought. Would that be a correct assumption?
(ps. in my limited experience with AI chatbots, they seem to be either completely scripted, or otherwise random and often incoherent, which is what leads me to believe that they do not maintain a train of thought)

First, for almost every question of the form "Can AI be made to X", the most obvious and straightforward answer is something like "We don't know. Probably, but if it hasn't been done yet, we're really not sure."
It's also important to understand that, from a technology standpoint, there isn't one "thing" called "AI".  There are many, many different technologies, which are loosely related (at best) and are generally lumped together under the overall rubric of "Artificial Intelligence".
All of that said, yes, there has been work on adding memory, even long-term memory, to various kinds of "AI".  The most notable recent example is the advent of LSTM in recurrent neural networks.
Additionally, some of the work done on "cognitive architectures" has focused on the use of memory.  For more info on that, look up ACT-R and/or SOAR and read some of those papers.
What isn't clear to me offhand, is whether or not anybody has tried applying any of these techniques to chat-bots in particular.  I wouldn't be surprised if somebody had, but I can't cite any such research off the top of my head.

+1. Though LSTMs are 20 years old. The most notable recent example is probably rather Deepminds neural turing machines.

Fair enough.  It's "recent" relative to the development of perceptrons / ANN's in general, but I guess most people wouldn't really call something "recent" that is 20 years old.  :-)

It could be said that "maintaining a thought" is a basic requirement of computing, and can be represented as a string of binary digits in the context of a Turing Machine.
"Basically, it occurred to me, that when I'm thinking or speaking, there is a constant feedback loop, in which I am formulating which words to use next, which sentences to form, and which concepts to explore, based on my most recent statements and the flow of the dialogue or monologue. I'm not just responding to outside stimulus but also to myself. In other words, I am usually maintaining a train of thought."
This sounds an awful lot like a recursive function.
My analysis of the chatbot problem is that it reveals a poor quality reasoning on the part of the bots, as opposed to lack of reasoning. It's not so much a question on the raw ability of an algorithm to maintain a train of thought, because the "train of though" is the function itself, but the quality of the algorithm and, by some measures, the "humanness" of the output.

what I mean though, is an ai that actually has a train of thought. That is, an ai that is aware of it's most recent statements, and that will take those statements into consideration, in order to continue a "train of thought". I haven't actually looked at any chatbot code (and wouldn't understand it if I did), but I'm under the impression that chatbots usually only respond to user input (and don't maintain a train of thought).

@SebastianHahn Awareness of past statements, and previous user inputs, would simply be an additional function.  Implementing such a system is trivial from a coding standpoint.  The difficulty, again, is with the quality of the output, which in this case, ideally passes a "Turing test".

Unless I am misunderstanding something, it would not be trivial. Simply due to the fact that, while bots can learn response patterns, they often lack an understanding of the relationships between the various concepts which their statements and responses describe (and lacking an understanding of those relationships, a bot would not be able to maintain a coherent train of thought).

@SebastianHahn I strongly concur that applying meaning is exceptionally non-trivial, but the disagreement may be semantic, in the sense of "coherent to whom?" (i,.e. coherence is a spectrum and subjective.)  If we define coherent as "logical and consistent", a response that is meaningless to humans could, and must, still be coherent in an algorithmic sense to functionally produce output of any kind.  Coherent to a human is a different animal, and here is a function of a "Turing" threshold.


text:
Why do neural networks based AI players still require extensive search techniques?
Today we have neural network based AI players that are comparable or better than humans in games that require extensive pattern matching and "intuition". AlphaGo is a prime example.
But these AI players usually have both neural networks and search algorithms in place. Humans, on the other hand, rely just on the pattern matching and "intuition" (even the best chess players can see just a handful of moves ahead).
So, why do AI players still require extensive search while humans don't? How would AIs like AlphaGo perform if we take the search part out?

Humans, on the other hand, rely just on the pattern matching and "intuition"  -- define "intuition".  And how do you know that humans don't use search algorithms?  It's not like we fully understand human intelligence yet.. after all, if we did, it would probably be trivial to implement "artificial intelligence" on that basis.

@mindcrime I suppose human searches are not more than a few ply deep, at least consciously (unless it happens subsconsciously without us realizing).

It is not very accurate to say that AI players requires extensive search while humans don't. Rather, it is a question of degree.
AIs do a lot more calculating, because that's what computers are good at.
Human intuition is much more powerful than a neural network can currently hope to match, because it is much more integrated into a world of knowledge about the game, it uses orders of magnitudes more neurons and it is not a static thing that just provides a move.
But if a human player stops calculating ahead his playing strength will drop very significantly. This can be seen by assessing the performance in games with short time controls: The less time you have the less calculation is happening, your intuition however is fast.
If you take out the search component of AlphaGo it would still play quite strongly, probably at a low dan level. Of course that is also far below its strength.
So, search is always an important component of playing strength, just more so for machines.

My takeaway from the few research papers I've perused is that avoiding deep search is preferred, per the extreme size of the Go, and even Chess, gamespace.

@BlindKungFuMaster Thanks. "...it uses orders of magnitudes more neurons" - So, if AIs had a bigger neural networks, they'd be able to maintain their levels with even much shallower humanlike 2-4 ply search?

@Achilles It may help to think of it as a ratio, where, in a condition of intractability for any given processing capability, the shallower the search, the greater the number of branches that can be explored.  The number of optimal plies is partly a factor of number of branches per ply, minus those branches that are pruned.  I doubt there is a hard, optimal number of plies for ML Go, b/c larger data have greater utility. Thus it may be more of a question of "How many plies do I need in order to achieve the desired outcome."

@Achilles: If you have enough data to train it, a bigger network will be better. If your network is better you will need less search for the same strength. But some details have to be calculated, not everything drops out of generalising over big datasets. And finally, 2-4 ply is a gross underestimate of how deeply decent human players calculate. In chess middlegames I usually calculate roughly 10 ply ahead. The tradeoff is more visible in search breadth.


text:
Will artificial super-intelligence evolve to have selfishness inherent in biological systems?
A lot of experts have expressed concerns about evil super intelligence. While their concerns are valid, is it necessary, what are the chances or how the artificial super-intelligence will evolve to have selfishness and self protecting desires inherent in biological systems? Is there any work which comments on this line of inquiry?

Possible duplicate of Could an AI feel emotion?

@Mithrandir So far two question have been duplicated from one question;and this Can Robots learn how to feel suffering?

@quintumnia Not necessarily a duplicate imho, because this question is about "self interest" in a game theory context specifically, as opposed to useful traits related to "self interest" that could arise out of game theoretic applications of automata (genetic algorithms and evolutionary game theory.)

AI will only "evolve" selfishness if it "evolves" in a competitive environment and has certain human-like faculties.
Self-protecting desires on the other hand are logical consequences of having any goal at all. After all, you can't reach your goal if you are destroyed.
The concern of "evil" super intelligences isn't that they literally turn evil and selfish and cruel. Those are human qualities.
Instead a superintelligence that has a certain goal, will logically pursue subgoals that help it to reach the ultimate goal. Such subgoals will be resources, power, safety.
So it will amass power and resources to reach its goal and exterminate any threat to its existence as long as its goal hasn't been reached, without being selfish at all.

Hello BlindKungFuMaster,Can you please first have a look at duplicated questions.

@quintumnia: I don't think this question is a duplicate of the emotion or of the suffering question. Selfishness is neither an emotion nor a feeling. Also, the other questions are missing the AI-threat aspect. I really don't see much similarity.

I have some comments on this subject here: https://ai.stackexchange.com/a/2878/1671
This is some deep game theoretic stuff, and it partly depends on how you define "selfishness".
There is such a thing, for instance, as a "greedy algorithm".  Sometimes a greedy algorithm is the most convenient way to achieve an acceptable result, but the optimality is only local.
On a mathematical level, the constructiveness or destructiveness of "self interest" in a system may be a function of whether a Nash Equilibrium is perceived.  In this case, self-interest is defined as maintaining the current strategy, because, unless the competitor changes their strategy, there is no gain for changing one's own strategy.
As the BlindKungFuMaster importantly notes, competitiveness will evolve as a trait if the AI operates in a partisan context.
There, the problem comes from whether the "game" is zero sum (Pareto Optimal) or non zero sum (Pareto Improvable), or both.  Here, "destructive" may defined agents made worse off per the gains made by another agent.
Altruism seems to have a rational basis, and occurs in evolution because it is presumably useful. [See Biological Altruism.]
Although this tends to be confined to single species, the co-evolution of dogs and humans is a case for inter-species altruism, based on self interest.
Humans and machines have also, and will continue to, co-evolve.


text:
Training neural network for good taste in art
I'm a newbie in machine learning, so excuse me in advance). I have an idea to make NN that can estimate visual pleasantness of arbitrary image. Like you have a bunch of images that you like, you train NN on them, then you show some random picture to NN and it estimates whether you'll like it or not. I wonder if there is any pervious effort made in this direction.

This question reminds me of a project I saw that used Deep Learning to rate selfies on twitter. But a quick google search shows that there are plenty of projects that are much closer to what you are interested in:
Rating Image Aesthetics using Deep Learning
Predicting Image Aesthetics with Deep Learning
Deep Understanding of Image Aesthetics (with data and model linked)
Understanding Aesthetics with Deep Learning
and probably dozens more.
Of course if you are interested in predicting subjective pleasantness the above is only a beginning. In that case you may also take a look at recommender systems.

I see a main concern with the problem you show and that is the subjectiveness of the term like, what I like is not the same of what you don't like, maybe I like more ciricular shapes and lou like best rectangular ones. The main problem is that with such an subjective label, is difficult to create a global model.

Very good comment.  I've met people who spend money on work I think is gauche, and by the same token, they find my taste to be bewildering.  It seems to me that subjectivity is the value here, in that, such an engine could be used to match people of particular tastes with work that would likely appeal to them.

Of course, a dataset well designed and appropriate in terms of size, would eventually find, clusters of likeness between different individuals. But, and it is my opinion, I think the problem is far more complex than we can imagine, since there is no absolute truth, and NN struggle with problems that have an absolute truth, like object recognition, so maybe could be one of the challenging problems in the future of Affective Computing

That sounds like a pretty straightforward application of a NN classifier to me.  I don't know if anybody has done that specific thing or not, but I don't see any particular reason to think it wouldn't work. My advice to you is to just jump in and do it.

I don't think anyone has done it yet,but you could try.
A way you could implement it is  having a quite efficient CNN trained on the things you like,then your program should ask the user if he does like some images and on the answers he will give, your program will finetune the original network and then with the fresh-trained one you should obtain good results.


text:
Assigning probability to output of a ReLU network
I'm using a NN created with CNTK's SimpleNetworkBuilder to make choices (specifically in board games). I specified ReLU as the layer type, so outputs can be arbitrary numbers.
When evaluating a custom set of features, getting the "choice" of the function/model is simple: Look for the output signal with the highest value. However, there are times when I wish to introduce some randomness and assign probabilities to each output signal, then select the choice based on each output's probability.
Currently, what I'm doing is manually normalizing all the output using a sigmoid function specified here: https://en.wikipedia.org/wiki/Logistic_function
Then, I multiply them all by a scalar such that the sum total of all outputs is 1.
At this point, I pick a random number 0..1, and see where along the map it falls; that is my selected choice.
What I'd like to know is, is there a better way?

"softmax" function

I would just skip the sigmoid function step.
Consider these two scenarios with three choices with the associated values:
0.1,10,100 or 1,100,1000
Given that these scenarios are equivalent in their relativ values, your probabilities should be assigned in the same way. But if you throw in a sigmoid function, the difference between 10 and 100 will be bigger than between 100 and 1000.
Just normalise the values, so that they sum to 1. In that case the choice with a value ten times higher than the value of another choice will be picked ten times as often. Makes sense to me.


text:
Is there a "better" (signal-based) language for artificial intelligence
I assume, there must be "signal-driven" and maybe also real-time programming language, which based on connectivy-data more than variables (int, string, etc).
I would like to have a language without equaton (x=4) but more like "x related to 4" or "cat related to animal" etc...

Consider what similarity means. Similarity is a metric which is going to be calculated mathematically. Even if you are using bins intuitively, that is in essence, a quantized set.

What You need are other ways of knowledge representation, such as semantic networks or conceptual graphs. there you can define any possible relation between your entities. the knowledge of "x related to 4" exactly fits into "frames" and "semantic networks".
Jaynes in his book,discusses thoroughly what "plausibility" means and why we need to take into account weak syllogisms and start using probability theory as a platform for developing a (general) AI. this might also help with your "reasoning" phase (after you've developed your knowledge base)

jaynes' idea is very clever, but i am missing a language like c++/java but signal-based and can handle millions of neuron-like classes. I thought there will be a special language for this.

@Andy Check this out. (Specifically as an answer to the question in your comment)

thanks, vhdl seems to be very appropiated. I am working on a similar but very simple language with "ports" and signals like: value1.change.connect.value2.set and should mean value2 = value1 . it is longer than mathematical way but i hope it will more far more intuitive.

I don't know if this is what you want, but Artificial Intelligence Markup Language or simply AIML is something that you should consider.
The only problem I see with this language is that it is not popular thus there aren't many compilers for it.

Here is an example of AIML.
Code from tutorials point :
<aiml version = "1.0.1" encoding = "UTF-8"?>
   <category>
      <pattern> HELLO ALICE </pattern>

      <template>
         Hello User!
      </template>

   </category>
</aiml>

Result :
User: Hello Alice
Bot: Hello User

Thanks, didnt knew about it. I like the idea merging "data" and "code" together. Also something like a databank or like here xml code must be more representive than a poetry-like code. But i also think it must be structure for neurons or cluster of neurons


text:
Has anyone attempted to train an AI to learn all languages?
It seems that most projects attempt to teach the AI to learn individual, specific languages.
It occurs to me that there are relations in written and spoken words and phrases across languages - most of use have a much easier time learning more languages after we learn a second language, and we start to understand the relations between words and phrases in different languages.
Has anyone attempt to train an AI to learn all languages?
Wouldn't this potentially be a much simpler problem than trying to teach an AI a single, specific language with all of the specifics and details of that single language? Since you're actually omitting a lot of related data in other languages from the training set?

One basic problem is the question "what does it mean to teach a computer system a language?" Language is an instrument for communication, so there would have to be something to communicate, which is not necessarily a trivial issue. Suppose you have a system that "knows" a language, what would it do with it?

There are approaches in machine translation that try to capture this kind of synergy between languages. The idea is that if you train your architecture to be able to translate English-Japanese, Japanese-English, Korean-English, English-Korean it will also be able to translate from Japanese to Korean without ever having seen a single such training example. Here, you can read about this so-called zero-shot translation.
It is also possible to train wordvectors on several languages at once, which might give you better wordvectors for a language with few training examples.
Of course for true language understanding you have to solve the grounding problem and I'm not sure using several language will help with that.


text:
Recent work on “Oracular” systems such as Eliza?
I know Eliza is considered a Natural Language Processing application, but the application of NLP in this context is “Oracular”.
What I mean by Oracular is that the systems was designed to produce ambiguous output to facilitate the instinct of the user to read meaning into the answer.  (My experience with Eliza was as a child on a 64KB system and the program could fool the user for a little while based on sheer novelty, although the limitations were quickly revealed by repetition of output.  For kids, this actually became a game of tricking the program into saying funny things;)
This method has a long history in oracles, the most famous certainly being the early binary symbolic system of the I-Ching.  (Times being simpler in ancient days, the idea was that a workable amalgam of the universe could be constructed (2)+(4)+(8)+(64) symbols.  Each set of symbols is defined by the meanings of the set of the previous order and modified by sequence, which is the key for explaining a given symbol.) The output is ambiguous enough that it may be applied to any input, and rather than the system understanding the input or output, it requires the user to provide the analysis.  This may be said to be an engine for generating human insight about a problem. (Monte Carlo may even be utilized, although the sage, working to attain an understanding of each of the symbols, may use intuition to match input with output.)
The reason I ask is I believe this demonstrates a very ancient, algorithmic method of engaging the human mind without the requirement that the algorithm understand the input or output--merely that it produce output to which meaning can be ascribed.
(This almost certainly relates to the relative success of “pornbots” beating the “Turing test” in that the user is chemically induced to read meaning into a given output or string of outputs.)

Aspects of the grounding problem are what got me thinking about this.  Not sure if it's relevant that the broken and unbroken lines in the I-Ching represent on and off bits and can be extended to circuits as open and closed.

You would be very interested in the blog post The History of Text Generation, which discussed similar approaches to generating ambiguous outputs.

Tariq's comment hints at this, but this is still in some sense a very mainstream idea.
Check out the transcripts for this year's Loebner Prize. The winner (called Tutor) is again making use of Eliza-like deflections. Some of the other candidates try to use seduction (Columbia), or speaking in a flighty or insistent way (like 2017's Rose).
In all cases, the bots are relying on humans to read meaning into ambiguous or vague statements, which we seem to be hardwired to do. Kind of neat!


text:
The relation between the human face perception and the keyword spotting in speech recognition?
In our brain there is an area, near the fusiform gyrus and the occipital area, to recognize the human face. And in speech recognition, there is a technique named keyword spotting. Then I am wondering 1) if there is an area in our brain for the similar function to recognize our names; 2) if a special face recognition function should be considered when we are building a robot?

Specialised neural circuitry to recognise faces is common in all our closest animal relatives. This means that it is likely an evolutionary adaptation that is many millions of years old. Babies can pay attention to faces basically from the moment they are born. There are certain types of brain damage that make it impossible to recognise faces.
Being addressed by an individual name (as opposed to broadcasting an individual signature) is likely a much more recent phenomenon. I have never heard of babies having any special propensity to pick up on names and I have never heard of brain damage that makes it selectively impossible to hear your name.
Also, face recognition can be hardwired because faces always look roughly the same. Names are always different. If you have to learn them anyway, it is more likely that it just happens with you general auditory brain stuff.
And it strikes me as likely that the speed that comes from special circuitry (recognising something early in the cortical hierarchy) is a lot more essential when it comes to faces (and snakes and spiders) then your own name.
So, while humans pay close attention to every sound that might be their name, I doubt there is specialised neural circuitry for that.


text:
How to deal with changing video frame sizes in a CNN?
How to deal with videos where the frame sizes are not the same frame to frame?
For example this video moves up and down and when it does, the video part of the screen has a different amount of pixels vertically.
How to deal with different frame sizes in a CNN?

,Don't you think your question lacks something there? or it's me who isn't analyzing critically

Well, the easiest way in order to make different frame sizes work with a convolutional neural network, is to process them using a different operations such as scaling, and or cropping in order to make them the same size. I do not know of any way currently where different frame sizes can be inputted directly into the neural network, as in order to do that you would need to almost completely change the neural network architecture. If the frames have a small difference in size, you may be able to get away with scaling the frame to the dimensions of the largest frame. This also depends upon what kind of problem you are trying to solve. While this method would work if you are trying to classify an image into a couple categories, it would not work if your are trying to do tasks such as object location. If you are doing one of the latter tasks, you should be able to pad the image with blank pixels in order to make the frame you are trying to process the dimensions of the largest one. This would work quite well, especially for object location detection. Finally, another solution is to crop the larger images to the size of the smallest one. While this will work just as well as padding, if you need any image data from the very edges of the frame, this will not work very well. So in conclusion, there are three different methods you could apply. Me personally, I would go with padding because it does not remove any important image data, and it will work very well for tasks such as object location detection. If you are doing a classification task though, scaling would work also. Finally, you could crop the images, but this would have to be evaluated for your specific task.

If you pad many of the training images, will the network learn to look for padding?

@user3731622 it depends upon how your training data is structured. If you have enough training data, and one class does not have a specific padding size to it, then you should not have any issues.

Thanks.  I've just come across Global Average Pooling (GAP). Instead of dense layers after CNN, I seem to recall someone suggesting GAP could be used to handle variable input image sizes for CNN.  I'm not sure how this works yet, but thought I would share.  Here is one useful link


text:
How to train a neural network for a round based board game?
I'm wondering how to train a neural network for a round based board game like, tic-tac-toe, chess, risk or any other round based game.
Getting the next move by inference seems to be pretty straight forward, by feeding the game state as input and using the output as the move for the current player.
However training an AI for that purpose doesn't appear to be that straight forward, because:

There might not be a rating if a single move is good or not, so training of single moves doesn't seem to be the right choice
Using all game states (inputs) and moves (outputs) of the whole game to train the neural network, doesn't seem to be the right choice as not all moves within a lost game might be bad

So I'm wondering how to train a neural network for a round based board game?
I would like to create a neural network for tic-tac-toe using tensorflow.

Great question!  NN is very promising for this type of problem: Giraffe Chess.  Lai's accomplishment was considered to be a pretty big deal, but unfortunately came just a few months before AlphaGo took the spotlight. (It all turned out well, in that Lai was subsequently hired by DeepMind, although not so well for the Giraffe engine;)
I've found Lai's approach to be quite helpful, and it is backed by solid results.

You may want to use "sequential" as opposed to "round based" since sequential is the preferred term in Game Theory and Combinatorial Game Theory, and these are the fields that apply mathematical analysis to games.
The games you list are further termed "abstract" to distinguish them from modern strategy boardgames, or games in general, which utilize a strong theme and are generally less compact than abstract games in terms of mechanics and elements. This carries the caveat that abstract games are not restricted to sequential games or boardgames, or even games specifically, as in the case of puzzles like Sudoku.
The formal name for this group of games is generally "partisan, sequential, deterministic, perfect information" with the further categorization of Tic-Tac-Toe as "trivial" (solved and easily solvable) and non-trivial (intractable and unsolved) for games like Chess and Go.

I'm a chess player and my answer will be only on chess.
Training a neural network with reinforcement learning isn't new, it has been done many times in the literature.
I'll briefly explain the common strategies.

The purpose of a network is to learn position evaluation. We all know a queen is stronger than a bishop, but can we make the network know about it without explicitly programming? What about pawn structure? Does the network understand how to evaluate whether a position is winning or not?

Now, we know why we need the network, we'll need to design it. The design differs radically between studies. Before deep learning was popular, people were using the shallow network. Nowadays, a network with many layers stands out.

Once we have the network, you'll need to make a chess engine. Neural network can't magically play chess by itself, it needs to connect to a chess engine. Fortunately, we don't need to write position evaluation code because the network can do that for us.

Now, we have to play games. We could start with some high-quality chess databases or instead have our AI agent play games with another player (e.g. itself, another AI agent, or a human). This is known as reinforcement learning.

While we play games, we update the network parameter. This can be done by stochastic gradient descent (or other similar techniques). We repeat our training as long as we want, usually over millions of iterations.

Finally, we have a trained neural network model for chess!

Look at the following resources for details:

https://www.chessprogramming.org/Learning

I think you should get familiar with reinforcement learning. In this field of machine learning the agent interacts whit its environment and after that the agent gets some reward. Now, the agent is the neural network the environment is the game and the agent can get a reward +1 if it wins or -1 if loses. You can use this state, action, reward experienc tuple to train the agent.  I can recommend David Silver's lectures on youtube and Sutton's book as well.


text:
Feasibility of an AI assistant to expedite game development?
Basically, an AI that can create, rig, and texture 3d models and game environments (by extrapolating from collections of reference models, according to user input), and that can set up physics and mechanics (assuming that the AI has access to a 3d modeling studio and a game engine, both designed for compatibility with the AI, or as a component of the AI), all according to user commands (and allowing for tweaking and optimizations of models, rigging, mechanics, etc, by the user).
An example of user commands would be something like: "Gaming AI, create a casual style* male model, European build, 6'5", fit and slightly skinny, with red scaly skin, green eyes, a reptilian tail, demonic wings, claws, sharp teeth", etc. The user probably wouldn't add all of these characteristics at once, but rather one at a time, tweaking each feature via AI commands or manually.
*"casual style" is a fictional "style class". Style classes would refer to the visual style of the models. Possible example styles include "cartoon", "abstract", "gothic", "steampunk", "serious" and "realistic".
Here's another example of user commands, for a environmental model: "Gaming AI, create a serious style house, Victorian, two story, white with beige trim, with porches and shutters. Give it a creepy aesthetic." Again, models could be created and modified or have features added in a step by step process, in order to tweak and refine them.
I believe that such an AI would significantly reduce the amount of time, labor, and difficulty involved in designing games; making games cheaper and easier to produce, and making game design available to everyone. A variation of such an AI could also be used to create 2d artwork and animations.
But is such an AI even remotely possible? And would it take a supercomputer to run the thing? (I'm under the impression that such an AI would need to be capable of learning and adapting, and would require a massive and expansile "association library"*—including 2d and 3d models, and verbal and textual speech—as well as near human intelligence)
*if the term "association library" doesn't exist, or doesn't currently relate to AI, Then I just made it up. According to my made up definition, an association library is the library of programmed or learned associations that an AI uses to generate responses, and to, in this context, generate 3d models; and probably to write or select code as well, in order to set up physics and mechanics and the like.

I realise this question was asked a couple of years ago, but I think it's worth reflecting that the OP asked an insightful question, as indeed the gaming industry is now actively working on the questions and ideas raised by the OP.
Indeed, huge sums of money are now being invested in the AI field within the gaming industry, given the increase to productivity it would produce.
You might find this YouTube video interesting, which discusses the topic of producing game elements from description, and ray-tracing techniques.  It's not produced from a AI research/developer-perspective, but certainly a useful overview of where things stand mid-2019
https://www.youtube.com/watch?v=fQlQQSsC47g

Thanks for the video! This is excellent! The world has changed a fair bit and I believe this is possible today, to an extent. What are the best examples of AI driven tooling you know? I'm working on this, just getting started (modest start but hopefully goes far) with https://himochi.com


text:
What are state-of-the-art ways of using greedy heuristics to initially set the weights of a Deep Q-Network in Reinforcement Learning?
I am interested in the current state-of-the-art ways to use quick, greedy heuristics in order to speed up the learning in a Deep Q-Network in Reinforcement Learning. In classical RL, I initially set the Q-value for a state-action pair (S,a) based on the result of such a greedy heuristic run from state S with action a. Is this still a good idea in the setting of a neural network for the approximation of the Q-function, and if yes, what are the optimal ways of doing it? What are other ways of aiding the DQN with the knowledge from the greedy heuristics?
References to state-of-the-art papers would be highly appreciated.

You can check out Bootstrapped DQN, with a demonstration video. Without reading much of the paper, it seems the authors use a different sampling strategy and an action-guide for specific instances.
Another way to initially set weights for the network is to create a dataset of moves (correct, incorrect, etc, as long as they are relevant) and have the network initially learn the dataset. This also helps debugging, as you can see whether the network can actually learn the policy used in the dataset. After learning the dataset, use the same learned network with DQN and start with a smaller exploration rate (like 0.5 instead of 1.0).


text:
Feature extraction other than convolutions for images?
Are there approaches other than convolutions to learn features from images? Has there been any research to use approaches such as hashing (e.g. p-hash, diff-hash etc.) in lieu?

Some more complex and better outcomes are those that include the MPEG-7 developed by the MPEG group.
These descriptors specify the video standard in question. They are split for color, shape, texture and movement.
1. Color Descriptors
Color Space. Specifies the data type of the color space in which they are expressed or work other color descriptors. Color spaces that it contemplated are: RGB (Red, Green Blue), YCrCb (Luminance, Chrominance), HSV (Hue, Saturation, Value), HMMD (Hue, Maximum, Minimum, and Difference).
Color Quantization. This descriptor defines a uniform quantization of a given color space.
Dominant Color(s). This descriptor is the most suitable to be used in images, or regions, in which a small number of colors is sufficient to characterize the information of one determined region.
Scalable Color. This descriptor consists in a color histogram in the HSV space. It is useful in image to image comparisons or searches based on color characteristics.
Color Layout. This descriptor allows representing the color spatial distribution within the images in a very compact way, so the recovery is realized with great efficiency.
Color Structure Descriptor. This descriptor characterizes the color distribution in an image. It builds a color histogram, which assigns most importance to the colors that appears most often and spread across the image. GoF/GoP Color (Group of Frames/Group of Pictures). This descriptor is an extension of the Scalable Color descriptor, which, unlike the latter, is applied to video sequences (a collection of images) instead of only an image.
2. Texture Descriptors
Homogeneous Texture. This descriptor emerged as an important tool when looking for and choosing within large collections of images of great visual similarity.
Texture Browsing. This descriptor specifies the perceptual characterization of one particular texture, and pretend be similar to the characterization that a human eye makes, according to regularity terms, coarseness and directivity.
Edge Histogram. It is a descriptor that gives us information on the type of contours or edges that appear in the image.
3. Shape Descriptors
Region Shape. The object´s shape in an image may consist of a single region or a set of regions, so this descriptor is useful for this type of characterization.
Contour Shape. It is characterized by very well represented contour features which facilitates subsequent search and retrieval; it is robust to motion, to occlusions and to different perspectives; it is extremely compact.
Shape 3D. The Shape 3D allows to describe in details the shape in 3D. This tool is very useful today due to continuous development of multimedia technologies.
This was taked from my paper: The MPEG-7 Visual Descriptors: a Basic Survey
Best regards

I think your question addresses the fact that convolutional neural networks utilize convolution and not some other mechanism. This answer addresses other feature extraction techniques you can use on image. In general, there are a number of other feature extraction mechanisms you can look into.

Histogram oriented gradients. Counts the occurrences of gradients in an image and generates bins. These bins can be then used directly as features.
Color data. You can extract color histograms of various granularities and use this data to train a model.
Hough Transform - Can identify shapes and lines and other spatial features.

On top of these we also have numerous techniques on top of convolutions like gradients, curvature finding, corner detection, and ridge finding.


text:
Is it illegal to use pictures of public figures to train a neural network?
I want to train a neural network with pictures of public figures (politicians, singers, etc), but I do not know if it's legal, I do not plan to show them in my project I only want to use them to train the neural network, can this cause legal problems?

If you use any pictures you find online, you can use them as you wish: as long as you don't (re)publish them under your name. Also, if you really want to play safe, never upload them at all. Download them, use them, disregard them.
People can't proof you used certain pictures to train your network by looking at your network data.
And the 'big' companies out there, like Google, train their networks by using public photos.
And follow this chart:

As you are using it for a personal/educational project, it shouldn't be a problem.

@sanandresm the point about re-publication is that someone likely holds the copyright on those images.  "Fair use" generally applies to creative content that is being excerpted, such as in a documentary or article.  In your case, it's not an issue, as you are not going to be re-publishing any of the content, and are merely using it in-house for research.  I have a good deal of experience with Intellectual Property law, but I am not an attorney, so if you have any outstanding concerns, I'd recommend asking this question on Stack Law.

It depends on the country. In France, for example, you've got to have the agreement of the person. Doesn't matter whether he is the president, a singer or... me :)
Edit:
Doesn't matter what for. Your image belongs to you. Otherwise he (me) can sue you for that and seek redress. Faces of persons are blurred in Google Map Street View. Here is a link, in french.
About re-publication, you'll also have to have the agreement of the copyright holder.

Thanks for posting!  Here are some links regarding the recent changes:
DISPOSITIONS RELATIVES À LA LIBERTÉ DE CRÉATION ET À LA CRÉATION ARTISTIQUE  ("PROVISIONS RELATING TO FREEDOM OF CREATION AND ARTISTIC CREATION").  Article on TechDirt


text:
Multi-param LSTM input
Lets say you install your LSTM machine on a road between London and Oxford. And it makes observations. A car with 3 people inside drives past it in one direction 21 sec after previously observed car (in any direction) : the input is {3, LO, 21}. A bus with 43 people drives in other direction 11 sec later : {43, OL, 11}
I cant find a definitive general explanation (without references to existing ML packages code) - how your LSTM layer structure should look like to accept those params (there are 3 of them and they are vastly different between themselves but presenting them together at each step is very significant (as opposed to splitting them to 3 streams and feeding then into 3 LSTMs and then pooling the results).
Could someone explain it in a single formula or a drawing?

So you want your network to represent those 3 values at each step as single composite value? I can't think of any better way than utilizing 3 LSTM units but attaching them to same write and read nodes of the enclosing network. In other words your assumption that it makes sense to keep all those 3 values together, gets hardcoded into your network by making 6 connections (3 connected to read and 3 to write) share their weights. Usually researchers leave it to the network to decide whether to keep such composite values together or separate (by learning read and write weights through backpropagation) and sometimes network chooses to keep them together all on its own like in https://youtu.be/93rzMHtYT_0?t=531 (it can be seen how network resets whole bunch of LSTM units simultaneously ).


text:
Neural network Model to infer inputs given an output
I have a data set with four inputs and one output. I need to infer the 4 inputs given an output. What is the best way to do this?

I'm assuming that you mean your inputs are 4-dimensional vectors and your outputs are 1 dimensional vectors. If you think that the output vectors give you enough information to completely determine the inputs (at least approximately), then just treat your 1D "outputs" as inputs and your 4D "inputs" as outputs.
Another case is that very different inputs are mapped to similar outputs in your dataset, and you really just want to compute a prototype input for a given output. For example, you might want to produce an image of the letter "a" from only its one-hot label. There are many ways to do this. Here's one that I think is cool:
First, train a neural net the way you normally would with 4D inputs mapping to 1D outputs. Now let's say you're given a 1D output y. Generate some 4D noise x' and pass it through the net to obtain y'. Now pretend that the values in this input are parameters in your network, and hold your actual parameters constant. Use y and y' to compute a loss, and perform gradient descent on your synthetic input. If you repeat this enough times, you should get something that your network thinks deserves the output y.


text:
Spam Detection using Recurrent Neural Networks
I am working on this code for spam detection using recurrent neural networks.
Question 1. I am wondering whether this field (using RNNs for email spam detection) worths more researches or it is a closed research field.
Question 2. What is the oldest published paper in this field?
Quesiton 3. What are the pros and cons of using RNNs for email spam detection over other classification methods?

I don't think any type of linguistic pattern detection is a statistics problem. It is a semantic pattern recognition problem that relies on probability and statistics as part, but only part, of the mathematical, scientific, linguistic, and psychological tool set used to approach and design a solution to the problem.

Please, next time, ask only one question per post.

Question 1. I am wondering whether this field (using RNNs for email spam detection) worths more researches or it is a closed research field.

Use of RNNs to detect spam grew out of the use of artificial networks to detect fraud in telecommunications and the financial industry as a result of the rise of attacks on long distance lines, ATMs, banks, and credit card systems in online and at data centers supporting physical points of sale.
Although basic RNN design has given way to the newer LSTM and GRU approaches and its variants and extensions, artificial networks are now one of the primary fraud detection technologies. The dominance of this fraud detection strategy extends to SPAM detection, with its close ties to fraudulence. The spammers present the appearance of a relationship with their recipients that does not exist.
The improvement on computing designs to recognize patterns in time series data and the application of those designs for fraud detection and countermeasures and the detection and routing or deletion of of unwanted incoming information will be a stable area of research and development for the foreseeable future.

Question 2. What is the oldest published paper in this field?

There is no oldest published paper. The first papers on RNN are given in this answer: Where can I find the original paper that introduced RNNs?, but the move from pattern based detection to artificial networks to stateful artificial networks was gradual. The earliest deployments of these networks in server side or client side solutions occurred before any papers were published on the specific topic of RNN use in spam detection.

Question 3. What are the pros and cons of using RNNs for email spam detection over other classification methods?

Spam also has a strong temporal element.  What one considers undesirable spam in one year may be considered mission critical email a few years later, and vice versa. The performance in this space includes speed, accuracy, and reliability of classification, but also adaptation to changing user classification needs.
It is because of these four performance characteristics in tandem that stateful networks derived from RNNs are commonly used for spam detection. The need for gated learning and forgetting at the cell level to support the variable adaptivity makes the LSTM and GRU variants common choices.
Semantic document classification is riding on an emerging set of technologies, which are primarily artificial network designs that begin to broach the threshold of cognitive understanding of the text by storing linguistic structure in forms that allow analogy, comparison, and composition between them. Semantic algorithms that perform these operations on fuzzy associations in combination with recursive artificial networks may emerge as the dominant design as such designs are further developed.
References
Detecting Spam Blogs: A Machine Learning Approach, Pranam Kolari, 2006
Automated labeling of bugs and tickets using attention-based mechanisms in recurrent neural networks, Volodymyr Lyubinets et. al., 2018
Spam Filter Through Deep Learning and Information Retrieval, Weicheng Zhang, 2018
An Unsupervised Neural Network Approach to Profiling the Behavior of Mobile Phone Users for Use in Fraud Detection, Peter Burge, John Shawe-Taylor, Journal of Parallel and Distributed Computing, Volume 61 Issue 7, July 2001, pp 915-925
Intelligent junk mail detection using neural networks, Michael Vinther, June 2002
Mining for fraud, Margaret Weatherford, IEEE Intelligent Systems, 2002
Discovering golden nuggets: data mining in financial application, D Zhang, L Zhou, IEEE Transactions on Systems, Man, and Cybernetics, Part C: Applications and Reviews, Vol. 34, No. 4, November 2004
A Comprehensive Survey of Data Mining-based Fraud Detection Research, C Phua, V Lee, K Smith, R Gayler - Arxiv preprint arXiv, 2007

Initially, spam detection relied on simple rule based techniques to sort out spam. However following Paul Graham's famed article 'A Plan for Spam'  the Naive Bayes approach became very popular to the point that it became regarded as the baseline for dealing with spam.
However following breakthroughs in deep learning, researchers have now turned their focus to neural networks to help them deal with the perenial problem of spam emails. Google recently reported that by introducing NN's to g-mail's spam filters. It took them from 99.5% to over 99.9% accuracy, suggesting that neural networks especially when used in conjunction with Bayesian classification may be effective for enhancing spam filters. You can refer to the link below to read about Google's success story https://www.wired.com/2015/07/google-says-ai-catches-99-9-percent-gmail-spam/
Developing a spam filter using neural networks is basically a classification problem. You need to follow the steps below to develop such a system. (Nikhil B 2016)

Collect a dataset of spam and legitimate email messages. Label these datasets. You can find email and spam datasets here http://csmining.org/index.php/spam-email-datasets-.html
Process these messages with feature extraction and vectorising techniques i.e. tf-idf vectorizer, word2vec, bag-of-words e.t.c.
Once you have vectorised the dataset succesfully, apply a supervised learning NN algorithm i.e. radial basis network, multi-layer perceptron (MLP) or backpropagation.
Train your labelled data-set on the neural network. Once training is complete you can use cross validation to calculate the precision of your trained model using the test dataset.

Some of the advantages of using NN's for spam detection over other methods include.

Neural networks have a higher accuracy of identifying spam as demonstrated by google.
They have a lower false positive rate compared to other methods such as rule based techniques.
Their main disadvantage is that they require specialised computing hardware to deploy.

Some old influential papers published in the field include.
Machine Learning Techniques in Spam Filtering (2004) http://ats.cs.ut.ee/u/kt/hw/spam/spam.pdf
Detecting Spam Blogs: A Machine Learning Approach (2006) https://www.aaai.org/Papers/AAAI/2006/AAAI06-212.pdf
A review of machine learning approaches to Spam filtering (2009) https://www.sciencedirect.com/science/article/pii/S095741740900181X


text:
Input/output encoding for a neural network to learn a grid-based game
I am writing a simple toy game with the intent of training a deep neural network on top of it. The games rules are roughly the following:

The game has a board made up of hexagonal cells.
Both players have the same collection of pieces that they can choose to position freely on the board.
Placing different types of pieces award points (or decrease opponent's points) depending on their position and configuration wrt one another.
Whoever has more points win.

There are additional rules (about turns, number and types of pieces, etc...) but they are not important in the context of this question. I want to devise a deep neural network that can iteratively learn by playing against itself. My questions are about representation of input and output. In particular:

Since pattern of pieces matter, I was thinking to have at least some convolutional layers. The board can be of various size but in principle very small (6x10 on my tests, to be expanded by few cells). Does it make sense? What kind of pooling can I use?
How to represent both sides? In this paper about go, authors use two input matrices, one for white stones and one for black stones. Can it work in this case too? But remember I have different types of pieces, say A, B, C and D. Should I use 2x4 input matrices? It seem very sparse and of little efficiency to me. I fear it will be way too sparse for the convolutional layers to work.
I thought that the output could be a distribution of probabilities over the matrix representing board positions, plus a separate array of probabilities indicating what piece to play. However, I also need to represent the ability to pass the turn, which is very important. How can I do it without diluting its significance among other probabilities?
And most importantly, do I enforce winning moves only or losing moves too? Enforcing winning moves is easy because I just set desired probabilities to 1. However when losing, what can I do? Set that move probability to 0 and all the others to the same value? Also, does it make sense to enforce moves by the final score difference, even though this would go against the meaning of the outputs, which are roughly probabilities?

Also, I developed the game engine in node.js thinking to use Synaptic as framework, but I am not sure it can work with convolutional networks (I doubt there's a way to fix the weights associated to local perceptive fields). Any advice on other libraries that are compatible with node?

To represent the pieces, you should be able to use a single input matrix. Just designate an integer number for the different types of pieces. White stones can be positive integers and black stones can be negative.
You can use sigmoid for board position confidence and linear activation for piece identifier. pass would be another sigmoid output. I don't think you'll have to worry about pass being diluted. Since it is such a valuable action, the score will depend a lot on the pass output and it will have a large gradient. If you need to select the pass action with high frequency for reinforcement learning purposes, then just attribute a higher probability to the pass action in your random choice function.
The final score difference has a large impact on the desirability of the moves. A large score difference should result in a large impact on the function. Therefore you might want to include the magnitude of score difference in your loss function.

This is the type of job that Deep Q Learning does. Perhaps you'll want to look into that too.

You don't need conv layers, since you don't feed a picture as an input (see below). Alternatively, you can try using a picture of the board (with different pieces having different shapes). This can work too. Then I would go for 2 conv layers, stride 1, kernel size equal to half a piece size. I would try it with a single max pooling.
Unlike the other answer i would suggest using a 3d tensor as an input, with the number of channels equal to different pieces. The other two dimensions equal would correspond to number of cells on the board. Various transformation in you NN will not be able to distinguish between multiple integers very well. That's why it is better to have a one-hot encoding of the pieces' types.
I would use only a vector with n+1 components for output: n for all possible moves, and 1 for the pass. It would encode the expected reward for each move, not the probability.
Not sure what you mean by enforcing moves. But when you going to train it with something like Q-learning it would make sense making a completely random move every once and a while with a certain probability (say 10% of the times). Lookup https://en.wikipedia.org/wiki/Reinforcement_learning


text:
seq2seq vector to letters model
I'm looking to build a sequence-to-sequence model that takes in a 2048-long vector of 1s and 0s as my input and translating it to my known output of (a variable length) 1-20 long characters (ex. GBNMIRN, ILCEQZG, or FPSRABBRF).
My goal is to create a model that can take in a new 2048-long vector of 1s and 0s and predict what the output sequence will look like.
I've looked at some github repositories like: https://github.com/llSourcell/seq2seq_model_live/blob/master/2-seq2seq-advanced.ipynb https://github.com/hans/ipython-notebooks/blob/master/tf/TF%20tutorial.ipynb
but I'm not sure how to implement it with my problem. Are there any projects that have done something similar to this/how could I implement this with the seq2seq models currently out there?


text:
Can we implement ML engine using any general purpose Micro controller?
I have read some articles, some tutorials but I am still didn't implemented any AI system. So , My question may seem inappropriate for the giants in this field. But I have build certain program , downloaded to microcontroller and it will perform its task. But How to do all this with machine learning. Can I implement AI engine using C like language and make it working in any GPP uC? Please feel free to modify, edit and upgrade this questions if you get my actual problem idea.

It depends on what you mean by "ML engine" and whether you want to train models on the uC or just make predictions.  IF you're doing something simple (maybe linear regression, logistic regression, etc.) you might be able to get away with doing training on a uC, especially for small amounts of data.  But you're almost certainly not going to be training deep neural networks on one of those things, at least not in any reasonable amount of time.
OTOH, the "making a prediction part" is usually much cheaper computationally, so if you have a pre-trained model and some prediction engine that can use that model, you could possibly use that on a microcontroller.

Absolutely, but it almost certainly won't be as strong as companies that design for specialized processors.
For instance, NVIDIA Drive for autonomous vehicles is marketed as a "supercomputer".  (Autonomous vehicles cannot rely on a network for decision making, so the vehicle needs a computer up to the task.)
A good example of specialized micro-processors, pre-GPU, is Digital Signal Processors, where the architecture was driven by the focus on multiplication in common digital signal processing algorithms. (Binary multiplication is much more expensive than addition/subtraction in terms of operations.)
I suspect much of the recent success of "monte carlo" has to do with brute force, but I need to confirm that.
The whole point of high-level languages is to be able to operate on different processors without having to customize for each processor, as with machine languages.  Most C languages allow bitwise operations, so you'd be able to take advantage of that, although interpreted languages such as Python appear to be extremely popular for AI, probably due to the flexibility in terms of testing code without needing to compile.


text:
Tuning the parameters of Particle swarm optimization (PSO)
To tune the parameters of Particle swarm optimization (PSO), there are two methods offline and online. In offline manner, the meta-optimization is used to tune the parameters of PSO by using another overlying optimizer. In the online manner, there are two techniques, Self-Adaptation, "consisting of adding some or all of the optimizers behavioural parameters to the search-space, thus making them subject to optimization along with the problem at hand". Another technique is Meta-Adaptation ," in which an overlaying optimizer is trying to tune the parameters of another optimizer in an online manner during the optimization of a problem."
"The concept of meta-optimization. A black-box optimizer is used in an offline manner as an overlaying meta-optimizer for finding good behavioural parameters of another optimization method, which in turn is used to optimize one or more actual problems."
In standard PSO the particles are initialized by using uniform random numbers and these particles are updated using update equations. the best solution is selected based on the best value of objective function.
In my work. I have two data sets, training and theoretical dataset and I need to initialize the particles by using training data instead of random numbers.
In this case, how can I tune the parameters of PSO using training and theoretical data set.
Also, I have a problem which is, I got the best cost in the initial step of PSO and in the initial step there are no parameters or update equations.
Is it possible to tune the parameters using Machine Learning method? How can I do this?

I am working also on a similar issue. These sources might help: Algorithm Runtime Prediction: Methods & Evaluation; Tuning Metaheuristics. I think a problem that I faced is to elaborate some features of the problem, which has not been yet elaborated. Best regards.


text:
What are the criteria for choosing Turing award winners?
Why does not a researcher like Geoffrey Hinton with his valuable works in machine learning (especially neural networks) get Turing award?

He won it for 2018 along with Yoshua Bengio and Yann LeCun :)

The ACM A.M. Turing Award is an annual prize given by the Association
  for Computing Machinery (ACM) to "an individual selected for
  contributions of a technical nature made to the computing community".
  It is stipulated that the contributions "should be of lasting and
  major technical importance to the computer field". The Turing Award is
  generally recognized as the highest distinction in computer science
  and the "Nobel Prize of computing".


text:
Why can't computers be random?
I talked with a graduate computer science who said one challenge of making artificial human-like is making random decisions, and that computers can't be random, that they always need a "seed." But, if a computer's outcomes are determined by the chaotic movements of electrons, it doesn't seem like it should be difficult to program inherent uncertainty into a computer. So, what exactly is stopping people from harnessing this basic component of reality to allow artificial intelligence to make randomized decisions? I mean, all you'd need is different neural pathways that rely on the superposition of electrons, and that's it.

Simply because we are at a level of Artificial Narrow Intelligence or ANI

True Randomness doesn't exist in classical physics (or world). It only exists in Quantum World. Systems doing random things is not very useful in itself. Though today we have many that can stimulate a certain degree of randomness that is useful in various fields. Imagine a system that performs its actions randomly and decided randomly to kill you or any other human or something even worse. Careful what you wish for.

Computers (the processor in combination with the memory) are designed to be deterministic.  Otherwise no software would ever work, because the computer would be executing it randomly.
The computer's outcomes are not determined by the chaotic movements of electrons, but by the much strong deterministic currents and voltages between the transistors.  A digital machine is, simply speaking, not affected by noise.  The noise is always present,  but 0.13 volts or whatever gets rounded to 0 V (logic 0) and 3.02 volts or whatever gets rounded to 3.3 V (logic 1).
It is however possible to take advantage of the chaotic movement of electrons as well.  This is done in special hardware called "hardware random number generators", (some use different forms of true randomness such as nuclear decays).

I mean, I can't really find where I stated computers aren't currently designed to be deterministic, so I'm not sure why you brought that up. I'm speaking in reference to making an AI random so that it emulates chaotic decision making that humans sometimes have. I'll look into the hardware random number generators though.

You can't simply program it to become analog.  It actually requires specialized hardware.

Right, but I'm wondering why that has been so difficult given it's such a fundamental property.

It's not difficult, it's just not needed in most cases.  There's enough randomness from the outside world (microsecond timing of IP packets and mouse movements for instance) to seed a cryptographically secure pseudo random number generator.

And installing a high quality hardware RNG is not difficult, but it costs money and very few people would ever need it.


text:
Is there a computer vision service for classifying images on a fixed array of images provided by me?
I was checking services like Microsoft Azure's Cognitive Services Computer Vision API and Google's Vision API and they are amazing. I was wondering if these services, or any other cloud service for that matter, can recognize an image's content and classify it on a set of fixed categories defined by me, not by the Cognitive Service provider.
For example, I have different products and I will take several pictures of each product. I want to then use the cloud service and upload all the pictures of each product, so that I can then take a picture of one product and the Computer Vision algorithm will tell me which product I am seeing.
Is it possible? Is there a third party solution for this problem? If so, how many pictures do I need to train each product's recognition?
I hope I was clear. Thanks in advance for any light on the topic!

Actually I'm trying the same thing with the Azure Computer Vision API. Although the API is very good in identifying objects, it has problems identifying specific consumer products (in my experience though). For example it can't really distinguish between two pair of shoes, or two pair of watches.
People recommended me using the: Custom Vision Service combined with Custom Decision Service. I haven't really looked in to them both. But maybe it's useful for you.

You can check the cloudcv : https://cloudcv.org/trainaclass/
you can use the web service or call throw matlab or python api


text:
Ensemble Learning using Convolutional Neural Networks
I have created 22 different Convolutional neural networks that all test for the presence of unique objects in an image (each one of the classifiers is unique).
Each sample in the test set has the output of a 22-long vector that looks something like this [0, 1, 1, 0, 0, 1, ..., 1], the binary nature of the vector representing the presence/absence of specific objects.
I have implemented this already in keras and reach around 97% accuracy avg for the 22 models. Is there any specific ensemble methods that can allow me to combine all 22 classifiers?

I think it is not a very good idea because Im pretty sure you used for learning all these 22 CNN same images and even same way for giving them a batches of images. So basically in a result you would have almost the same 22 classifiers.

I am new to AI but this is something I can think of. There might be other much better ways. Or even functions in scikit learn to do it
1) create a list of all the 22 models
2) iterate over the models one by one and use model.predict() for each model and store the hotencoded output to another list or numpy array.
3) Take average of the output list or numpy array.
4) since the output is a vector of 0,1 it is possible to get decimals in the output after taking avg. Round it off using the basic rules to either 0 or 1.
5) If your CNNs are very deep like inception v3, densenet etc. You might run into memory issues while loading all the 22 model's weights into the memory at once. So you can iteratively load the models in small fixed batches and use model.predict() on each model in the batch append the outputs to a list. and then clear them off the memory before loading another batch of models.
This is just my idea. I might be completely wrong also.

For this task, I think you shouldn't use 22 different networks. Use only one. The last layer of the network should be a fully connected with 22 unit, each unit represents the presence of a unique object. The activation function for this layer is sigmoid which output a real number between 0 and 1. Each of these outputs represents how confident the network about the presence of that unique object.


text:
Multi-Label Image Classification using KNN
I'm not quite sure how I should go about creating a multi-label image KNN classifier using python as a lot of the literature I have read does not explicitly explain this methodology. Specifically, I am not sure how I would be able to potentially yield multiple labels per image using the KNN classifier architecture. Any insight would be greatly appreciated! (new to coding by the way)

Have you tried google searching? There are many results that come up for "multi-label k nearest neighbor image classification". Here are the first couple of papers to get you started:
http://proceedings.mlr.press/v25/chiang12/chiang12.pdf
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.86.9501&rep=rep1&type=pdf


text:
How would 1D gradient descent look like?
We have always known that gradient descent is a function of two or more variables. But how can we geometrically represent gradient descent if it is a function of only one variable?

For a function of one variable, there are only two options for directions in the domain: left or right, so it becomes almost trivial, but you can still talk about gradient descent.
You would take steps to the left if the slope/derivative is positive and make steps to the right if the slope/derivative is negative--i.e. the opposite direction of the derivative (the 1d version of the "gradient" in gradient descent), which is equivalent to the higher dimensional case.

"The concept of a direction of fastest descent only makes sense in more than one dimension."
https://math.stackexchange.com/a/180573

I think this answer is not correct. See the other answer: https://ai.stackexchange.com/a/19883/2444.


text:
Converting pictures into numerical values
I am working to make my first trained model for image recognition, using the programming language R.
First I am attempting to make a function that takes a PNG-image as input, resizes it to 128x128 pixels, and converts it into a row-vector of numbers representing the colours in each pixel. I then want to add this to a file that contains my training-set and labels (the image bank).
I am having some trouble with this, being a beginner in R, as the numerical values I get out from the following code does not make sense to me - often I get a large amount of 1's, and the pictures appear to be completely white if I try to export and look at the image.
Is there any obvious mistake here? I assume it must be where I convert to numerical values. Alternatively, is there an alternative approach to this task that would be better?
load_png_to_image_bank <- function(wd, input_file, label) {

  # Remembers old working directory
  oldwd <- wd

  # Sets input wd to file location
  setwd(wd)

  # Loads imager package
  library(imager)

  # Imports file and resizes to 128x128 pixels
  image <- load.image(input_file)
  image <- resize(image,128,128)

  # Finds numerical values for each pixel
  rasterized_vector <- as.data.frame(as.vector(image))
  rasterized_vector <- as.data.frame(t(rasterized_vector))

  # Adds label defined by input variable
  rasterized_vector <- as.data.frame((cbind(1, rasterized_vector)))
  names(rasterized_vector)[1] <- label

  # Sets wd to predetermined place for image bank file
  setwd(" ... ")

  # Writes vector to file
  write.table(rasterized_vector,
              output_file,
              row.names=F,
              na="NA",
              append = T,
              quote= FALSE,
              sep = ";",
              col.names = F)

  # Resets working directory to initial state
  setwd(oldwd)

  }

Maybe it's better to submit this kind of questions to programming forums, such as Stack Overflow or R dedicated forum. It's more an R question rather than an AI question.


text:
Problem with the PLN classifier
I'm developing a chatbot, and to get the answer I'm using the Naive Bayes classifier by sorting the questions and answers. For those who want to see the whole project code and more definitions follow the link of GitHub
To develop I am using the TextBlob library for python, the problem is that when training my classifier it is always returning the same message, regardless of the input I use. The message is:

"Tudo bom?"

I still can not identify the problem, I do not know if the problem is in the way my data is willing to perform the training or if it is the way I am training the classifier.
My class that performs the sorting process is this:
#encoding: utf-8
#!/usr/bin/env python
from textblob.classifiers import NaiveBayesClassifier
from textblob import TextBlob
import logging

class Talk(object):
    """The Talk class is responsible for returning the response
    Based on the information exported. Using the classification
    According to Bayes' theorem
    """
    def __init__(self):
        """
        Class builder

        Cl -> Stores the classifier
        Accuracy -> Stores the accuracy of the algorithm
        """
        self.__cl = None
        self.__accuracy = 0

    def train(self, train_set):
        """
        Train with the list of information consisting of phrases and their
        Respective classifications:
        """

        logging.debug('Inicia treinamento da previsão de intenção')
        self.__cl = NaiveBayesClassifier(train_set)
        logging.debug('Treinamento da previsão de intenção finalizado')

    def test(self, test_set):
        """
        Performs tests with the list of information formed
        Of sentences and their respective classification to obtain the accuracy:
        """

        logging.debug('Inicia teste da previsão de intenção')
        self.__accuracy = self.__cl.accuracy(test_set)
        logging.debug('Teste da previsão de intenção finalizado')
        logging.info('Precisão da previsão: {}'.format(self.__accuracy))

    def response(self, phrase):
        """
        Returns the phrase response according to the created classifier
        """
        logging.debug('Analisa a frase "{}"'.format(phrase))
        blob = TextBlob(phrase,classifier=self.__cl)
        result = blob.classify()
        logging.debug('Resposta: "{}"'.format(result))
        return result

Follow the link in my file with training information and test data

Training
Test


text:
Grouping items by relationships of their owners
I have a set of data representing many sellers and the items they sell. There is an overlap between the various sellers' items. These items come from various distributors and typically an item comes from a unique distributor.
I am trying to come up with an algorithm that will group items by the distributors that sold them to the sellers. Any ideas come to mind?

Hello, welcome to AI.SE. Unfortunately, implementation questions are off topic you. You may want to try [datascience.se] or [stats.se].

Thanks a ton! Didn't realize that, appreciate the pointers.

What's your background with AI?  Are you also interested in high-level, general info on the types of AI methods that would be helpful in addressing this?  (i.e. there are several implementation-oriented Stacks related to AI.  It can be difficult for someone new to the field to identify which related Stack is appropriate.)  PS Welcome to AI!


text:
Streaming time series data to detect fraud?
I'm currently looking in to the possibility of using machine learning to detect fraudulent transactions on our website based on the events that happen for each user.
I'd like to be able to stream events in to it, such as sign up, order placed, inviting another user, etc along with the the time and some how come up with a probability of how likely it is that the person is acting in a fraudulent manner
I'm totally new to machine learning and everything I read goes straight over my head basically :/
Can someone please explain the type of neural network I'd need, how I'd decide how to set it up and how I would go about training it?

Elasticsearch with X-pack is a tool that would come in handy. The suite has an visualization engine, Kibana and logstash that collect, parse and transform the data telemetry.
https://www.elastic.co/products/x-pack/machine-learning
Modeling can take a while to learn, luckily there are tools like Elasticsearch that can help.
Grafana also has tools but does not have a specific AI engine to it.But has a lot of integration with third party fraud detection tools.
https://grafana.com/
Sridhar


text:
Are gradients of weights in RNNs dependent on the gradient of every neuron in that layer?
I am writing my own recurrent neural network in Java to understand the inner workings better. While working through the math, I found that in timesteps later than 2 the gradient of weight w of neuron n depends on the gradients of all neurons at all timesteps before. A handwritten example is given, I tried to write as clearly as possible.
Could anyone verify this so I can finish my network? Am I missing a piece or is my premise wrong, as in the output of a neuron is s(Wx + Vh + b), where h is the last step of only neuron n?

are you sure that is not your homework? why are you doing it in java python makes life easier.

Yes, I'm sure that this is not my homework, in fact I don't have any course related to this subject :). And firstly, Java is my preferred language, I can use other languages but I like Java the most. And speed i no concern for me. Secondly, I want to use this in another application which has to be in Java, so its just easier. Python may make dealing with arrays and numpy dealing with tensors easier, but I already got fairly good workarounds for that.


text:
How much data do I need to collect?
I'm trying to optimize a combination of 8 cards with 64 card characters. No repeats and order doesn't matter.
n!/(n!(n-r)!) = 4,426,165,368 combinations
I have everything set up, including the data scrapper. But I don't know how many games my machine needs to learn from to start seeing patterns. For example, in 14,000 games analyzed, only 834 decks had a certain character.
Analyzing the next 7 cards from 834 decks is 621,216,192
So I guess I need more data before reliable patterns emerge... but how much data? Thank you and god bless

The general rule: as much as you can get.

Sorry but no one can give you a number.
As stated already in the comment by Manngo, the general rule: is as much as you can. I have also seen the 10x number being thrown around, see here. According to this "rule", you need  roughly 10 times as many examples as there are degrees of freedom in your model.
How much data you will need is something you can only answers to through empirical investigation. The amount of data you need to collect is influenced by the complexity of the data, the dimensionality of the data and the algorithm you intend to train(although this can be controlled somewhat through regulirazation, see this good blog post by Jake Vanderplas for more information).
This question  might be of interest to you.