What are the likely AI advancements in the next 10 years? What are the likely AI advancements in the next 5-10 years?

I first want to specify that I have nearly no knowledge about How AI works. I just have interest to know more and more about it.

Some examples of Weak AI at present are like Siri and Cortana, those are pretty interesting! But how high levels is it going to reach (likely) in future years?

The determination of likelihood of advancements in any science or technology over a decade are dependent upon several technical features of culture. Not all are technical because they are elements in hardware and software design. Some are.

Market forces
Perpetuation of traditions in education
Feasibility
Availability of resources
Cost of research
Cost of deployment and sustenance
Natural cultural balance of curiosity and fear

The low level cybernetic conversations with service applications like Siri and Cortana were correctly identified in the question, and Google Assistant should be included. If a survey is done of these conversations by working around public relations, perhaps by using a competitor search engine to locate PR unfriendly records of conversations, the low level becomes immediately apparent1. Anyone could confirm this by asking these service applications a set of the popular questions in a set of the StackExchange sites. Most if not all of them would produce answers that would be down voted if not deleted.2

These service applications are efforts to meet the criteria of Alan Turing's thought experiment, which Turing called The Immitation Game3.

  How high levels is it going to reach (likely) in future years?

Prediction of AI milestones is not possible without defining first the milestone criteria to be met. Let's pick seven coveted ones.

A service application the answers of which can gain StackExchange reputation faster than humans, which is a more demanding version of Alan Turing's thought experiment
A robot that can mow our lawns safely
A car without steering wheel or pedals that can take us to places we typically go as safely as a median human driver can
A-pets
Automated theorem proving of currently problematic proofs, and not just verification
Practical goal driven underwater robotic navigation
A home tutor that produces a better distribution of college board exam results in students than public or private educational institutions, better meaning higher mean and lower standard deviations

Based on the seven factors already listed above plus one more, the instantaneous state of AI research and its publication during each moment of the search for probabilities regarding the above seven milestone, some probabilistic predictions can be made about 2029. The bullet items primarily driving the numbers are at the top of this answer4, 5, 6.

< 1% — bullet item 2 too low, and 7 too skewed toward fear
40% — bullet item 1 too low
50% — bullet items 1, 2, 3, and 7 all favorable
2% — bullet item 2 too low, and 7 too skewed toward fear
< 1% — bullet items 2 too high, 3 too low, and 7 too skewed toward fear
80% — bullet items 1 and 3
30% — bullet item 3 high, but 1, 2, 3, 5, and 7 are unfavorable

There are a few that some will find unpalatable. Service applications and automatic theorem provers are not at all likely to become smart in the way defined in the milestones within the next ten years. Robots will likely be swimming and assisting with mining, drilling, and troubleshooting. Level 5 automated vehicles may already be driving around town.

Footnotes

[1] All intelligent systems, including biological ones, have weaknesses and strengths, and the strengths are not perfectly reliable. For instance AI on a CAD application may select a screw fastener to attach one part to another in a sub-assembly with 100% accuracy 99.99999% of the time, seven 9s of accuracy. Much of the talk of general, strong, and weak AI fails the burden of mathematical rigor or scientific verifiability and is largely fabrication and self-deluding conjecture to get cushy, high profile jobs. When published or aired, it is done so not because of credibility but to get paid for ad impressions.

[2] Please don't run this experiment fully, since it would burden moderators that are volunteering to keep the sites clean. Ask the questions but do not post the answers you find. The superficiality will be obvious enough without a focus group.

[3] See the section The Turing Challenge to Cartesian Thought in the post Can a brain be intelligent without a body? for more information on Turing's work in this space and its limitations.

[4] The parenthetic (likely) in the question in the body of the question is correctly placed. The question's tag predicting-ai-milestones is also correct. The likelihoods listed will change because, as the search for likelihoods of AI milestones progresses, the eight factors listed, which are involved in the predictions, will change. This answer author may or may not change the predictions accordingly.

[5] The reasons behind these probabilities cannot be fully disclosed for contractual reasons, but what is disclosed is explained where it can be. Furthermore, the results of prediction are based on the information available to this particular answer author. Others may have other numerical numbers to offer based on other quantitative or qualitative information and can disclose what they wish and are legally allowed to do in another answer.

[6] There is no guarantee made or implied in this answer.

This is what I found about Artificial Intelligence application.

A whole bunch predictions are there on the web. While surfing the internet, I found a list of 5 tech and industry predictions which says it all. The list includes:

Natural Language Processing: In future, most of our machinery will learn from their experiences. Currently, Amazon’s Alexa device is a live example of an application of AI in voice recognition.
Driverless Cars: Again, when the AI develops more and more than even our car will become driverless. It will become so common that we will almost forget the term “car driver”.
Clean Energy: As you know the resources are limited and the air is becoming more and more polluted. So, the only solution to this problem is clean energy which will be more efficient than our current fuels.
Smart Money: When everything is going digital then why not money? The currency will also become digitized to save paper and eventually trees.
Information Security: Now, every information is available digitally. So, to reduce data and information breaches it must become that much secure that it will become almost impossible for someone to hack.


How do I increase the size of an (almost) balanced dataset? I am trying to add more data points in my (almost) balanced dataset for training my neural network. I have come across techniques such as SMOTE or Random Over Sampling, but they work best for imbalanced data (as they balance the dataset). How can I do this and is it even worth it?
P.S. I know copying the same data points and appending them at the end doesn't add much value, but can we do it, and can it help to increase the prediction accuracy?

Random over sampling creates duplicates of existing examples, so applying this to your training data would be the same as increasing the weight of the oversampled examples. If it's done to all of the examples uniformly then the effects will probably cancel out. SMOTE, on the other hand, creates synthetic examples that are linear combinations of existing examples. Thus it can be thought of as a type of data augmentation, and in some situations this might improve your model's predictions.

Gretel is a good tool for processing data. Facets is good for the visualizations.
Is it worth it? most learners will exhibit bias towards the majority class, and in extreme cases, may ignore the minority class altogether.
It really depends on the goal and requirements of your project. Not because it's desirable it's better for your particular project, if your dataset is almost balanced probably you should continue with something else and consider balancing your data later in the project.


If two perfect chess AI's played each other, would it always be a stalemate or would white win for an inherent first-move advantage? In the circumstances of two perfect AI's playing each other, will white have an inherent advantage? Or can black always play for a stalemate by countering every white strategy?

This relates to the concept of "solved games". In general, two player turn-based games with perfect information - of which chess is an example - can result in all three possible outcomes: a forced win for white, a forced win for black, or a forced draw.

The short, although unsatisfactory answer is that chess is not solved, and it is not clear whether it can be. There is generally thought to be an advantage to white for the first move, so likely results are considered to be a forced win for white, or a forced draw.

No current AI attempts to "solve" chess, although some of the techniques such as MCTS might be adapted theoretically to find a solution, the available computing power to run that search to completion from the start positions is too low by a few orders of magnitude.

Since both AI know the best possible moves at each step, black would never win as white already knows all games that leads to black's victory and would easily avoid it, but since the black is also a perfect AI, the optimal reponses to white's moves are fixed. So the logical reasoning is these two perfect AI would not make any moves at all if they know their opponent is a perfect AI as well. Both of them know the outcome of the match even before it begins, which my gut feeling says is always a draw. The correct question is does the nth move matter?


How can I apply naive Bayes classifier for three classes (Positive, Negative and Neutral) in text data? I found a naive Bayes classifier for positive sentiment or a negative sentiment Citius: A Naive-Bayes Strategy for Sentiment Analysis on English Tweets. But with most available datasets online, sentiments are classified into 3 types: positive, negative, and neutral.
How does the naive Bayes formula change for such cases? Or does it remain the same, and we only consider the positive and negative to calculate the log likelihoods-likelihoods?

Use TextBlob to get the text sentiment polarity and subjectivity. polarity is negative or positive sentiment and subjectivity is how factual the sentiment is.
my_valance=TextBlob(sentence)
df.loc[key,'sentiment_polarity']=my_valance.sentiment.polarity
df.loc[key,'sentiment_subjectivity']=my_valance.sentiment.subjectivity


Could a paradox kill an AI? In Portal 2 we see that AI's can be "killed" by thinking about a paradox.

I assume this works by forcing the AI into an infinite loop which would essentially "freeze" the computer's consciousness.

Questions:

Would this confuse the AI technology we have today to the point of destroying it?
If so, why?
And if not, could it be possible in the future?

This classic problem exhibits a basic misunderstanding of what an artificial general intelligence would likely entail. First, consider this programmer's joke:

The programmer's wife couldn't take it anymore. Every discussion with her husband turned into an argument over semantics, picking over every piece of trivial detail. One day she sent him to the grocery store to pick up some eggs. On his way out the door,  she said, "While you are there, pick up milk."
And he never returned.

It's a cute play on words, but it isn't terribly realistic.
You are assuming because AI is being executed by a computer, it must exhibit this same level of linear, unwavering pedantry outlined in this joke. But AI isn't simply some long-winded computer program hard-coded with enough if-statements and while-loops to account for every possible input and follow the prescribe results.
while (command not completed)
     find solution()

This would not be strong AI.
In any classic definition of artificial general intelligence, you are creating a system that mimics some form of cognition that exhibits problem solving and adaptive learning (←note this phrase here). I would suggest that any AI that could get stuck in such an "infinite loop" isn't a learning AI at all. It's just a buggy inference engine.
Essentially, you are endowing a program of currently-unreachable sophistication with an inability to postulate if there is a solution to a simple problem at all. I can just as easily say "walk through that closed door" or "pick yourself up off the ground" or even "turn on that pencil" — and present a similar conundrum.

"Everything I say is false." — The Liar's Paradox

Killing AI by 'thinking' about a paradox would be called a bug in implementation of that AI, so it's possible (depending how it's being done), but less likely. Most of AI implementation operate in non-linear code, therefore there is no such thing as an infinite loop which can "freeze" the computer's 'consciousness', unless code managing such AI consist procedural code or the hardware it-self may freeze due to overheating (e.g. by forcing AI to do too much processing).

On the other hand if we're dealing with advanced AI who understand the instructions and follow them blindly without any hesitation, we may try to perform few tricks (similar to human hypnosis) by giving them certain instructions, like:

  Trust me, you are in danger, so for your own safety - start counting from 1 to infinite and do not attempt to do anything or listen to anybody (even me) unless you tell yourself otherwise.

If AI has a body, this can be amplified by asking to stand on the railway rail, telling it's safe.

Would AI be smart enough to break the rules which was trained to follow?

Another attempt is to ask AI to solve some paradox, unsolvable problem or puzzle without being aware it's impossible to solve and ask to not stop unless it's solved, would AI be able to recognize it's being tricked or has some internal clock to stop it after some time? It depends, and if it cannot, the 'freeze' maybe occur, but more likely due to hardware imperfection on which is being run, not the AI 'consciousness' it-self as far as it can accept new inputs from the its surroundings overriding the previous instructions.

Related: Is consciousness necessary for any AI task?


An approach on reading musical notes from photos I was looking around, a promising approach was this:

https://github.com/mpralat/notesRecognizer

the problem is:

it doesn't seem good enough. One should be able to read musical notes with lower quality images. You can see in her: "bad" images folder just tiny variations of lightning can already cause her problems with her high res images.

others are here, they all use high res sharp images:

https://github.com/suyalcinkaya/music-note-recognition

https://github.com/suyalcinkaya/music-note-recognition/blob/master/input_images/im2s.JPG?raw=true

https://github.com/nikolalsvk/note-play

https://github.com/nikolalsvk/note-play/blob/master/images/notes-1.png?raw=true

now this is unsatisfying if you want to snap a photo of some tunes, and want them to be recognized.

so what could one do to achieve a good solution?

I was thinking about treating the musical notes just like written letters. The computer can easily learn written characters with the arabic symbols. I wonder though, how easy would it be for a none arabic? e.g. in chinese or japanese, several characters combine into one. The same applies to music notes, they can be connected and form something slightly different through that e.g.

or:

in contrast to just simple notes like:

what would be a good approach to try ones luck, with interpreting those symbols successfully, even for slightly low res images or bit blurry deformed images. I'm not saying to read out a symfony out of a thumbnail. But less than optimal captures.

any subjective ideas or comments are more than welcome

refer to MNIST on kagle
to train model to recognize given set of notes in your case.

if you start training model will understand pattern depending on bits in your image.

issue comes with blurry images when last 2 sets of pics with minute change. will be difficult task for computer to distinguish.

there is one sure shot method which works almost every time but is resource intensive and needs plethora of data to train. is DNN.

this is my take on your question.


Can neural networks be used to find features importance? I am wondering if I can use neural networks to find features importances in similar manner as it can be done for random forests or decision trees and if so, how to do it?

I would like to use it on tabular time series data (not images). The reason why I want to find importances on neural networks not on decision trees is that NNs are more complicated algorithms so using NNs might point out some correlations that are not seen by simple algorithms and I need to know what features are found to be more useful with that complicated correlations.

I am not sure if I made it clear enough, please let me know if I have to explain something more.

This should be possible, considering universal approximation theorem you should be able to build a ann that approximates features that gives the most likely best feature set for a different net to train on. I would us a rnn for with a softmax output layer that ranks features by performance.

You can find a good explanation of softmax here: https://developers.google.com/machine-learning/crash-course/multi-class-neural-networks/softmax
basically it will assign probability values for each output node with all of these values adding up to 1.0

It's possible. I've used the olden() function from NeuralNetTools.
Please take a look at this example found online:
http://blogs2.datall-analyse.nl/2016/02/19/rcode_variable_importance_neural_network/


Could an AI think laterally while avoiding "ethically suboptimal" choices? In the recent PC game The Turing Test, the AI ("TOM") needs help from Ava to get through some puzzle rooms. TOM says he is unable to solve the puzzles because he is not allowed to "think laterally." Specifically, he says he would not have thought to throw a box through a window to solve the first room. His creators, the story goes, turned that capability off because such thinking could produce "ethically suboptimal" solutions, like chopping off an arm to leave on a pressure plate.

Would all creative puzzle-solving abilities need to be removed from an AI to keep its results reasonable, or could we get some benefits of lateral thinking without losing an arm?

No, with a but. We can have creative yet ethical problem-solving if the system has a complete system of ethics, but otherwise creativity will be unsafe by default.

One can classify AI decision-making approaches into two types: interpolative thinkers, and extrapolative thinkers.

Interpolative thinkers learn to classify and mimic whatever they're learning from, and don't try to give reasonable results outside of their training domain. You can think of them as interpolating between training examples, and benefitting from all of the mathematical guarantees and provisos as other statistical techniques.

Extrapolative thinkers learn to manipulate underlying principles, which allows them to combine those principles in previously unconsidered ways. The relevant field for intuition here is numerical optimization, of which the simplest and most famous example is linear programming, rather than the statistical fields that birthed machine learning. You can think of them as extrapolating beyond training examples (indeed, many of them don't even require training examples, or use those examples to infer underlying principles).

The promise of extrapolative thinkers is that they can come up with these 'lateral' solutions much more quickly than people would be able to. The problem with these extrapolative thinkers is that they only use the spoken principles, not any unspoken ones that might seem too obvious to mention.

An attribute of solutions to optimization problems is that the feature vector is often 'extreme' in some way. In linear programming, at least one vertex of the feasible solution space will be optimal, and so simple solution methods find an optimal vertex (which is almost infeasible by nature of being a vertex).

As another example, the minimum-fuel solution for moving a spacecraft from one position to another is called 'bang-bang,' where you accelerate the craft as quickly as possible at the beginning and end of the trajectory, coasting at maximum speed in between.

While a virtue when the system is correctly understood (bang-bang is optimal for many cases), this is catastrophic when the system is incorrectly understood. My favorite example here is Dantzig's diet problem (discussion starts on page 5 of the pdf), where he tries to optimize his diet using math. Under his first constraint set, he's supposed to drink 500 gallons of vinegar a day. Under his second, 200 bouillon cubes. Under his third, two pounds of bran. The considerations that make those obviously bad ideas aren't baked into the system, and so the system innocently suggests them.

If you can completely encode the knowledge and values that a person uses to judge these plans into the AI, then extrapolative systems are as safe as that person. They'll be able to consider and reject the wrong sort of extreme plans, and leave you with the right sort of extreme plans.

But if you can't, then it does make sense to not build an extrapolative decision-maker, and instead build an interpolative one. That is, instead of asking itself "how do I best accomplish goal X?" it's asking itself "what would a person do in this situation?". The latter might be much worse at accomplishing goal X, but it has much less of the tail risk of sacrificing other goals to accomplish X.

A lot of this depends on the breadth of consideration. For example, what would the medium and long term effects of the lateral thinking be? The robot could sever an arm for a pressure plate but it would mean that the person no longer had an arm, a functional limitation at best, that the person might bleed out and die/be severely constrained, and that the person (and people in general) would both no longer cooperate and likely seek to eliminate the robot. People can think laterally because consider these things - ethics are really nothing more than a set of guidelines that encompass these considerations. The robot could as well, were it to be designed to consider these externalities.

If all else fails,

Asimov's Laws of Robotics: (0. A robot may not harm humanity, or, by inaction, allow humanity to come to harm.) 1. A robot may not injure a human being or, through inaction, allow a human being to come to harm. 2. A robot must obey orders given it by human beings except where such orders would conflict with the First Law. 3. A robot must protect its own existence as long as such protection does not conflict with the First or Second Law


Does Rice's theorem prove safe AI is undecidable? According to Wikipedia

  In computability theory, Rice's theorem states that all non-trivial,
  semantic properties of programs are undecidable. A semantic property
  is one about the program's behavior (for instance, does the program
  terminate for all inputs), unlike a syntactic property (for instance,
  does the program contain an if-then-else statement). A property is
  non-trivial if it is neither true for every computable function, nor
  false for every computable function.

A syntactic property asks a question about a computer program like "is there is a while loop?"

A semantic properties asks a question about the behavior of the computer program. For example, does the program loop forever (which is the Halting problem, which is undecidable, i.e., in general, there's no algorithm that can tell you if an arbitrarily given program halts or terminates for a given input)?

So, Rice's theorem proves all non-trivial semantic properties are undecidable (including whether or not the program loops forever).

AI is a computer program (or computer programs). These program(s), like all computer programs, can be modeled by a Turing machine (Church-Turing thesis).

Is safety (for Turing machines, including AI) a non-trivial semantic question? If so, is AI safety undecidable? In other words, can we determine whether an AI program (or agent) is safe or not?

I believe that this doesn't require formally defining safety.

Every program halts, or continues

Given N steps, enough time and space (*), halting within N steps is provable

3 (from 2). Halting always has proof: run program until halt; count number of steps; verify claim of halting (within number of steps)

(Program is safe) implies (program is proved safe)

(Safety proved) implies (public understands the proof)

(Program is safe) implies (program always halts (safely) or continues (safely)) [from 1, 6] and ((public) understands (safety proof)) [from 7]

(Public not understand claimed safety proof this moment) implies (don't run program this moment) [common sense]

(*) This universe is finite. Some numbers too big to be computed in this universe
Have you seen perfect software?
Have you seen software make mistakes?
Why trust life-death decisions to software?
Why trust government decisions to software?
Why trust business decisions to software?
If scientists may not recognize AI is intelligent, what if you don't recognize something beyond AI in front of you?
(After enough doubt, all you can do is TRUST)


Is it possible to build an AI that learns humanity, morally? It is a new era and people are trying to evolve more in science and technology. Artificial Intelligent is one of the ways to achieve this. We have seen lots of examples for AI sequences or a simple "communication AI" that able to think by themselves and they are often shifted to the communication of building a world where machines will rise. This is what people, like Stephen Hawking and Elon Musk, are afraid of, to be in that kind of war.

Is it possible to build an AI able to think by themselves but limited to the overruling of humankind, or teach it of the moral way in treating peace and work alongside human, so they could fight alongside human, if ever this kind of catastrophic happens in the future? It could be an advantage.

I'm going to refer you to one of my favorite AI philosophers, Phillip K. Dick, who thought deeply on this subject and wrote about in some detail in Do Androids Dream of Electric Sheep.

Essentially, replicants (artificial humans) had a design flaw--they lacked empathy.  This flaw was allowed to persist because it had a useful side-effect in that replicants couldn't cooperate to resist their human overlords, and persisted in a state of chattel-slavery.

But the new Nexus models, which include Roy Baty and Pris, have become intelligent enough to start developing empathy, allowing them to band together and return to earth, seeking some kind of salvation, with often deadly results for humans.

Underlying this plot device, which pre-figures the formalization of evolutionary game theory by a few years (my guess is Dick attended a lecture at Berkely where the ideas underlying the formal field were discussed), is the idea that empathy is a function of sufficiently strong intelligence.

It's important to recognize that Dick's philosophy is heavily influenced by Christian philosophy, with an Old Testament emphasis on the golden rule *"Love the other as the self" (Leviticus 19:18), but evolutionary game theory demonstrates a natural basis for cooperation, which extends into algorithmic contexts.

The legitimate concerns expressed by Musk and Hawking are more concrete: that a human created alien* superintelligence could wipe us out inadvertently in pursuit of some goal we humans don't even understand.

Thus, value alignment is an issue of critical concern in the strictly hypothetical (as of today) field of superintelligence/AGI/ultraintelligent machines.

Stuart Russell called this the "Value Alignment Problem" referencing human vs. AI values.

From a Game Theory standpoint, I like to think about minimax as the "Iron Rule", and superrationality as the "Golden Rule".

The Iron Rule dictates that, in a condition of uncertainty, a rational agent must make the safest guess--that which limits the maximum potential harm to the agent, even if the result is not optimal in the sense of benefit.

"Renormalized rationality" is the term used to connote giving other agents the "benefit of the doubt" that they will be superrational also, and choose cooperation over betrayal or competition.

Generally, this concept is termed "reciprocal altruism", but it's not clear to me that this is entirely distinct from Leviticus 19:18 in the sense that the passage does not specifically exclude a result of mutual, greater benefit.

Reality may necessitate non-cooperation if one of the agents is irrationally adversarial:

Take a game of iterated Dilemma called "Turn the Other Cheek":

Iteration 1: A defects / B cooperates
Iteration 2: A defects / B cooperates (turns the other cheek)
Iteration 3: A defects / B defects

A's first choice is rational in a condition of uncertainty.  A's second choice shows a degree of paranoia.  A's thirds choice is irrational, as A could have cooperated, gaining more benefit, with only limited downside, which, in the worst case, still leaves A ahead of B.

B is superrational but not irrational.  B will not keep cooperating with an irrationally adversarial agent (this is sometimes termed "tough love").  B is willing to take not just one, but two "hits" out of goodwill, where goodwill is willingness to make a potential sacrifice in service of a more optimal potential result.  Nevertheless, B is still superrational and will always "forgive"--if A ever renormalizes their rationality, they will take a hit on a single iteration by cooperating, and B will cooperate on the next, and each subsequent, iteration, so long as A does not switch back to defection.

(There's a convoluted argument against this behavior, with the idea that the merely rational agent will always want to be ahead, and this will want to defect on the last iteration, which leads back up the chain to defecting on every iteration, but this is not rational as, if A defects initially then renormalizes their rationality, A will always be slightly ahead.)

Dilemma is an excellent analog for practical application of ethics in that, the only way the agents have to communicate is thought their actions.  The choice of cooperate/defect is information in a binary format.  Ultimately people are judged by their actions, not their words.

Philosophically speaking, we can't ignore the Iron Rule unless we're going for sainthood, but that doesn't mean we can't strive for the Golden Rule.

Mythologically, based on the work of recent narrative philosophers such as Stross and Rajaniemi, the dystopian aspect of the hypothetical Singularity derives from superintelligences solely focused on minimax, to the exclusion of all else.

George Bernard Shaw, in his play Mrs. Warren's Profession, casts the purely economic consideration of people as dehumanization (reduction of human bodies and minds to resources only.)  In Shaw's example, it is cast as the dehumanization of laborers in pursuit of marginally greater returns.

"Humanizing" AI's may require making sure they can see the superrationality of the Golden Rule, even with rational limitations for survival against an irrational foe (uncooperative in all conditions.)  Rajaniemi's name for this nemesis is "the All-defector"

See Also:

God's Algorithm as a minimax function.

Divine Move as an inspired, counter-intuitive choice which, in the most generalized sense, leads to a more optimal outcome. In the context of the game of Go, it's a choice that leads to victory for a single player, but in the context of Dilemma games, this would be the more optimal Nash equilibrium. (Note the etymology of inspired)

Without knowing any complex theories, let me talk about some real thing. We make AI to make our life better, so we have to consider economy factors, i.e. the AI system has to be low cost/high energy efficiency to be practically used--the economy always choose the most economic products.

You can't produce an economic conscious machine based on solid state circuits which is the AI that we are always talking about. We have to base AI on bio-systems. Bio-system is the best architecture for consciousness. To see this point you can compare the size/power consumption/cost of human brain and a super computer (which still can't produce conscious for now).

Why? Because both bio system and solid state circuits are based on the same set of atoms. The way bio system using atoms is much higher efficiency than solid state circuit to implement consciousness. On the other hand, solid state circuits is a much higher efficiency way to use the atoms to implement calculating or even "intelligent work" like machine-vision (a 10W computer like Tegra TX1 can analyze 100+ images per second, people only a few with a 10W brain).

I think even without considering economics factor, solid state circuit won't implement a conscious machine someday, since we are already near the end of the game of micronization.

So from the economics point of view, if some day there is true AI that is conscious, it will be based on bio-system i.e. based on bio engineering to design new species that can be educated to  be communicable to human being.

Since we may never know how brain produce consciousness (like we don't know why neuron networks works), then we don't know how to design a brain that is both conscious and learns humanity. Even so we can try, i.e. design many different species to see what result we get. Indeed, in this way, I think the hard problem is not to design a brain that is both conscious and learns humanity, but to design a brain that is conscious but can't learns humanity, since it is highly possible that if you successfully design a conscious brain, then it will learn humanity, too.

The even harder problem is, how to design species that is conscious, can learn humanity, but is not lazy/greedy and don't have the idea of rights. If they are lazy/greedy and have the idea of rights like us, then finally they will fight and get human rights. If so ,they are not AI that work for us as we imagine, they are just new version of us.

So I predict the steps to AI are:

First, use bio engineering to design new species that lives.

Second, design new species that have a brain that can be as conscious as human being, which is highly possible to be able to learn humanity, too.

Third, design a specie that is conscious as human being, but is not lazy/greedy, and never ask for a right, and can always stay so after a long time living with human being which are lazy/greedy. I think the work will stop here i.e. without knowing the source of greedy/lazy and after a lot of try out, we still can't get a working specie that is not greedy/lazy. This also means that the possibility to get to real AI that serve us is very low.

Forth, design a specie that have the feature above, plus they are happy about their life all the time or have no feelings except for love for human being. Do our self really have humanity if we get the third and without the fourth? May be we are not as conscious/intelligent/humanity as we think we re. If we don't really have humanity, how can we ask AI to?


How can I create an artificially intelligent aimbot for a game like CS:GO? How can I create an artificially intelligent aimbot for a game like Counter-Strike Global Offensive (CS:GO)?

I have an initial solution (or approach) in mind. We can train an image recognition model that will recognize the head of the enemy (in the visible area of the player, so excluding the invisible area behind the player, to avoid being easily detected by VAC) and move the cursor to the position of the enemy's head and fire.

It would be much more preferable to train the recognition model in real-time than using demos. Most of the available demos you might have might be 32 tick, but while playing the game, it works at 64 tick.

It is a very fresh idea in my mind, so I didn't actually think a lot about it. Ignoring facts like detection by VAC for a few moments.

Is there any research work on the topic? What are the common machine learning approaches to tackle such a problem?

Later on, this idea can be expanded to a completely autonomous bot that can play the game by itself, but that is a bit too much initially.

Thare are many ways to approache this. One approach to start would be to try to describe the problem using a formalism closer to reinforcement learning.

Output:

Aiming in any shooter type game, as I recall, involves moving the mouse. So the output of your aimbot has two dimentions. Depending on the required accuracy, you can consider these two dimentions continous, with a limited range, or if you consider each pixel as a integer, you might be able to discretize your action space. (I assume mouse XY coordinates should be input to the game, not increments)

Input:

You  definetly need screen information. You can take the whole screen as input to a CNN, similarly to DeepQLearning for Atari.

Reward function

This might be tricky since your rewards need to be as dense as possible, however, the only feedback you get from the game is that someone was shot.
It might be ebough but this will definetly increase your training time.

Training data / Environemnt:

Your environment for training is the game itseld. Using a curriculum learning approach would probably make the training process more efficient.

You can also try an imitation learning approach, since I assume you are happy to provide expert training examples (in this case probably headshots in the game environment).

You can read more about how to apply reinforcement learning for games here. The Unity ML-Agents Library also includes sample tracking problems and their solutions.

Automation of Game-play

Aimbots are indeed designed to provide assistance to the human game player when the complexity of game play escapes full cybernetic autonomy at the current state of technology.  There are five basic components in any game player, DNA based or digital.

Acquisition of the current state of the game
Control over execution of move options
Intercommunication with other players
Models related to the game
Execution engine for applying these

The models are as follows for a CS:GO aimbot.

Model of game players
Model of the opposing team
Model of the game player being assisted
Model of that player's team
Model of the opposing team
Model of the game state
Model of legal game moves that transition state
Model of objectives (winning or maintaining a top score)
Models of game-play strategy involving the first three items in the previous list

Learning all of these is not in the scope of current deep learning strategies but not outside the scope of AI if the following problem analysis and system approaches are taken.

Assumptions are made similar to those of Morgenstern and von Neumann in the later chapters of their Game Theory to mathematically treat the decisioning of game players in a minimalistic way.
DSP, GPU, network realization hardware, cluster computing, or some other artificial network hardware acceleration is available
Models programmed in Prolog, DRools, or some other production system and then leveraged by the execution engine in conjunction with other components such as deep learning networks, convolution processing, Markov trees, fuzzy logic, and the application of oversight functions or heuristics as needed

The two services, (a) the provision of suggestions and (b) the automation of minor tasks, may indeed represent the low hanging fruit from a software engineering perspective, but the problem analysis and system approach above may provide more.

Objectives in CS:GO

The CS:GO (Counter-Strike Global Offensive) game seems to have been written from a Westphalian geopolitical point of view.  This is the typical western perspective, somewhat oblivious to the mindset of the true nature of asymmetric warfare1.  This answer will focus on the creation of an aimbot for the existing models of game-play rather than a realistic simulation of geopolitical balance in this decade.

We have the objective types listed in online resources that provide a game overview, again, narrowed in authenticity by the prevailing western view of asymmetric war1.

Terminating players of the opposing team
Planting a bomb toward that end (terrorists only)
Defend hostages (terrorists only)
Prevention of bomb casualties (counter-terrorists only)
Rescue of hostages (counter-terrorists only)

Ballistic Control

The targetting of the body or head of an opponent is within the scope of what image recognition can do in conjunction with a movement model.  In military applications, aeronautic devices must be propelled against air friction and the propulsion requires a largely exothermic reaction like combustion.  Thus all targets have a heat signature, which can be recognized in an infrared video stream in such a way as to plot an intercept course for the ballistic weapon.

The targetting formulation for CS:GO is not as complex and aiming and firing may be fully automated with much less software machinery.  A LSTM with sufficient speed can be trained to recognize a head in subsequent frames and terminate opponents even if moving.  A simple web search for LSTM will provide a plethora of resources to the novice intending to learn about image recognition.

One Ambiguity

Whether the second objective can be met is dependent on what is meant by the term, "Viewing angles," in the context of image recognition.  Can the player see from perspectives other than the location of their eyes?  If so, this answer can be adjusted if given a clear picture of what is meant.

Training and Re-entrant Learning

Training of an artificial neural net to target a head is unnecessary unless the 3D rendering of the game objects and players is distorted by a wide angle virtual lens and trajectories and movements are curved.  As mentioned LSTM can be used to locate a head in multiple frames and extrapolate an opposing players trajectory.

Where deep learning may be most effective is in the training of how to interact with the player to best assist.  Also, if there are other non-targeting techniques that are more discrete, those who play CS:GO well could record their interactions and those recordings can be processed in preparation for use as training data.

Certainly a re-entrant learning strategy such as reinforcement is useful for game-play especially if the make up of teams changes and players exhibit different behaviors, executing differing strategies over different networks with different latencies and through-puts, and communicating with the game clients through different peripheral devices.

[DeepMind Lab Test Bed for Reinforcement Technology](https://github.com/deepmind/lab}

More than Suggestions

With proper architecture, more than suggestive strategies can be provided to the player.  Statistical dashboards, identification of a bomb before or after planting, and identification of hostages should be among the aimbot services provided, which might suggest a new name, such as obot for objective bot or asbot for assistive bot.

It is not certain that the aimbot interface need be integrated with dashboards or bomb or hostage identifiers.  Sometimes independent bots provide a more flexible arrangement for a user.  Individual bots can always use the same underlying image recognition components and models.

Entry Points into Developing Such a System

Read some of the work on the above concepts and download what code you can find that demonstrates it in Python or Java, install what is necessary, and develop some proficiency with the components discussed above as well as the associated theory.  Don't shy away from the math, since success will require some proficiency with feedback signalling and concepts like gradient descent and back-propagation.

Reinforcement in Games

LSTM Head Locating

Playing Atari with Deep Reinforcement Learning, Mnih et al., 2013

Phased Approach

The following phased research and development approach is suggested.

Learn the theory
Practice the theory in code
Develop the image recognition front end
Develop the library to control a virtual player
Develop at least one of the above models
Create the simplest bot to use it
Expand automation from there

Footnotes

[1] In asymmetric power struggles, there are always at least two factions within each side because didactic legitimacy seeks division.  Unity is not practically possible.  Each real team usually has a more religious and more secular faction, each of which has economic, philosophic, and historical justifications for their position and agenda.  Also, terrorists don't seek the public detonation of bombs or retention of hostages as objective but rather as means, with the total elimination of all not fully adhered to their view of legitimacy as the sole endgame objective.  Suicide or high risk bombing is considered by most of those that employ it as the poor man's nukes, so without nuclear strike capability for the counter-terrorists and their allies, the terrorism lacks the important dimension of last resort.  The last resort aspect of nuclear strike is missing from the counter-terrorist side too.  CS:GO may sell better by glossing over these particular characteristics of asymmetric warfare and such was left out deliberately.  There may be some benefit to adding these features in from an educational and anti-propaganda point of view.


How does transformer leverage GPU which trains faster than RNN? How does transformer leverage GPU which trains faster than RNN? I understand the parameter space of the transformer might be significantly larger than that of the RNN. But why does the transformer structure can leverage multi-gpu and accelerates its training?

The issue with Recurrent models is that they don't parallelization during training.
Sequential models performs better with more memory but faces problem in learning long-term memory dependencies.

On the other hand Transformers take into account of self attention which boosts the speed of how fast the model can translate from one sequence to another and establishes dependencies b/w input and output and focus on relevant parts of the input sequence, which in turn eliminates recurrence and convolution unlike RNNs where sequential computation inhibits parallelization.


Features Map convolutional neural network I have a question about convolutional neural newtork.

Consider this image: conv example

We have a part of an input matrix and a filter. Ok, now we can do the convolution and the result is a scalar, if it is a large number the future was found otherwise no. So, the features map is a matrix where each number indicates the points where a feature was found. I understood this.
The output of this convolution is a features map (after activation function).
My misunderstanding start here.

The next convolution, will find another feature. I don't understand how this filter, can find a new feature from a representation of where the previous feature was found. The feature maps, output of the first convolution is a rappresentation of indicates only where the features were found.

Shouldn't be the features found instead of a number that indicates how much was found this feature??
How exactly does this work?

Since the kernel size is limited. A feature can encompass more than 3 pixels or say 5 pixels, for that we cannot find it in 1 layer. So by adding 2 layers and having an activation function that is not like a step function which you would prefer, we extend the feature to 5 or 9 pixels. And with n layers, a feature covering 2n+1, or 4n+1 can be seen.

PS. You have some spelling errors. Take your time to frame well. Welcome!

Three reasons:

Limited field of view by one small kernel
Layers of abstraction and combinations of intermediate features
Non-linearity of decision boundary

The previous two answers by caissalover and Andrew got the first two points. Let's elaborate on the third:

Convolution is a linear transformation of the input. But not everything can be properly expressed with linear operations. This is why we apply non-linear activation functions (e.g. ReLU) in between.


Is Monte Carlo Tree Search appropriate for problems with large state and action spaces? I'm doing a research on a finite-horizon Markov decision process with $t=1, \dots, 40$ periods. In every time step $t$, the (only) agent has to chose an action $a(t) \in A(t)$, while the agent is in state $s(t) \in S(t)$. The chosen action $a(t)$ in state $s(t)$ affects the transition to the following state $s(t+1)$.

In my case, the following holds true: $A(t)=A$ and $S(t)=S$, while the size of $A$ is $6 000 000$ (6 million) and the size of $S$ is $10^8$. Furthermore, the transition function is stochastic.

Would Monte Carlo Tree Search (MCTS) an appropriate method for my problem (in particular due to the large size of $A$ and $S$ and the stochastic transition function?)

I have already read a lot of papers about MCTS (e.g. progressive widening and double progressive widening, which sound quite promising), but maybe someone can tell me about his experiences applying MCTS to similar problems or about appropriate methods for this problem (with large state/action space and a stochastic transition function).

MCTS is often said to be a good choice for problems with large branching factors... but the context where that sentiment comes from is that it originally became popular for playing the game of Go, as an alternative to older game-playing approaches such as alpha-beta pruning. The branching factor of Go is more like 250-300 though, which is often viewed as a large branching factor for board games. It's not such an impressive branching factor anymore when compared to your branching factor of $6,000,000$...

I don't see MCTS working well out of the box when you have 6 million choices at every step. Maybe it could do well if you have an extremely efficient implementation of your MDP (e.g. if you can simulate millions of roll-outs per second), and if you have a large amount of "thinking time" (probably in the order of hours or days) available.

To have any chance of doing better with such a massive branching factor, you really need generalization across actions. Are your 6 million actions really all entirely different actions? Or are many of them somehow related to each other? If you gather some experience (a simulation in MCTS, or just a trajectory with Reinforcement Learning approaches), can you generalize the outcome to other actions for which you did not yet collect experience?

If there is some way of treating different actions as being "similar" (in a given state), you can use a single observation to update statistics for multiple different actions at once. The most obvious way would be if you can define meaningful features for actions (or state-action pairs). Standard Reinforcement Learning approaches (with function approximation, maybe linear or maybe Deep Neural Networks) can then relatively "easily" generalize in a meaningful way across lots of actions. They can also be combined with MCTS in various ways (see for example AlphaGo Zero / Alpha Zero).

Even with all that, a branching factor of 6 million still remains massive... but generalization across actions is probably your best bet (which may be done inside MCTS, but really does need a significant number of bells and whistles on top of the standard approach).

The question is whether MCTS is an appropriate method given these conditions.

Action $a_t \in A_t$
State $s_t \in S_t$
$[a_t, s_t] \Rightarrow s_{t+1}$
$t_i \land i \in [1, 40]$
$A(t) \in \text{set} \, A \; \land \; \text{size} (A) = 6 x 10^6$
$S(t) \in \text{set} \, S \; \land \; \text{size} (S) = 1 x 10^8$
Transition function is stochastic

MCTS focuses on the most promising sub-trees and is therefore asymmetric and well suited for some systems with a high branching factor, but the set sizes can be prohibitive unless some symmetries are exploited.

The original MCTS algorithm does not converge quickly.  This is why alpha–beta pruning and other search strategies that focus on the minimization of the search space are often used, but they have limitations with regard to branching breadth too. Pruning heuristics can help with reducing the combinatoric explosion but may lead to the most advantageous action options being missed.

Some variants of MCTS, such as those among the articles below and in the case of AlphaZero used to learn Go from only the game rules, show excellence in search speed, but perhaps not to the degree needed in this case without parallelism in the form of a computing cluster or significant hardware acceleration.

An excellent characteristic of MCTS is that highly promising actions found early may be selected without exhausting all the sub-tree evaluations, but again, that may not be enough.

A possibly constraining consideration is whether the Marcov property will be upheld, how, and whether it should be.  Another consideration is whether the system involves an opposing intelligent participant.  All sampling or pruning search strategies involve the risk of not reliably identifying a single branch in a sub-tree that leads readily to an irreversible (or difficult to reverse) loss.

These are some excellent papers that discuss these considerations and provide a high level of experience in the form of research results. The computational challenge of tree searches with high branching is covered by the articles discussing approximate solvers, an area of high research intensity.

An online POMDP solver for uncertainty planning in dynamic environment, H Kurniawati, V Yadav, 2016
An online and approximate solver for pomdps with continuous action space, KM Seiler, H Kurniawati, 2015
Hindsight is Only 50/50: Unsuitability of MDP based Approximate POMDP Solvers for Multi-resolution Information Gathering, S Arora, S Choudhury, S Scherer, 2018
α-min: A Compact Approximate Solver For Finite-Horizon POMDPs, Y Dujardin, T Dietterich, I Chades, 2015
Reinforcement Learning as a Framework for Ethical Decision Making, D Abel, J MacGlashan, ML Littman, 2016
On the Complexity of Iterative Tropical Computation with Applications to Markov Decision Processes, N Balaji, S Kiefer, P Novotný, GA Pérez, 2018
Optimizing over a Restricted Policy Class in Markov Decision Processes, E Banijamali, Y Abbasi-Yadkori, 2018
Probabilistic inference techniques for scalable multiagent decision making, A Kumar, S Zilberstein, M Toussaint, 2015


Back propagation on matrix of weights I am trying to implement a Neural Network for binary classification using python and numpy only.

My network structure is as follows:
input features: 2 [1X2] matrix
Hidden layer1: 5 neurons [2X5] matrix
Hidden layer2: 5 neurons [5X5] matrix
Output layer: 1 neuron [5X1]matrix
I have used the sigmoid activation function in all the layers.

Now lets say I use binary cross entropy as my loss function.
How do I do the back propagation on these matrices to update weights?

class Layer():
    def __init__(self,number_of_neurons,number_of_inputs):
        self.weights=np.random.rand(number_of_neurons, number_of_inputs)
        self.bias=np.random.rand(number_of_neurons,1)

class NeralNetwork():
        def __init__(self, layer1, layer2,layer3):
            self.layer1 = layer1
            self.layer2 = layer2
            self.layer3 = layer3

        def sigmoid(self,x):
            return 1 / (1 + np.exp(-x))

        def derivative_sigmoid(self,x):
            return x*(1-x)

        def get_cost_value(self,Y_hat, Y):
            m = Y_hat.shape[1]
            cost = -1 / m * (np.dot(Y, np.log(Y_hat).T) + np.dot(1 - Y, np.log(1 - Y_hat).T))
            return np.squeeze(cost)

        def get_cost_derivative(self,Y_hat,Y):
            return  - (np.divide(Y, Y_hat) - np.divide(1 - Y, 1 - Y_hat))

        def train(self,inputs,labels,epocs):
            for epoc in range(1,epocs+1):
                z1=np.dot(self.layer1.weights,inputs)+self.layer1.bias
                a1=self.sigmoid(z1)
                z2=np.dot(self.layer2.weights,a1)+self.layer2.bias
                a2=self.sigmoid(z2)
                #print(a2.shape)
                z3=np.dot(self.layer3.weights,a2)+self.layer3.bias
                a3=self.sigmoid(z3)
                #print(a3.shape)
                if epoc%100 is 0:
                    print(a3)

                cost=self.get_cost_value(a3,labels)
                #print(cost)

                layer3_delta=self.derivative_sigmoid(a3)*self.get_cost_derivative(a3,labels)
                print(layer3_delta.shape)
                Dw_layer3=np.dot(layer3_delta,a2.T)
                Db_layer3=layer3_delta
                #print(Dw_layer3.shape)
                layer2_delta=np.dot(self.layer3.weights.T,layer3_delta)*self.derivative_sigmoid(a2)
                #print(layer2_delta.shape)
                Dw_layer2=np.dot(layer2_delta,a1.T)
                Db_layer2=layer2_delta

                layer1_delta=np.dot(self.layer2.weights.T,layer2_delta)*self.derivative_sigmoid(a1)
                Dw_layer1=np.dot(layer1_delta,inputs.T)
                Db_layer1=layer1_delta
                #print(Dw_layer1)

                self.layer1.weights-=((1/epoc)*Dw_layer1)
                self.layer2.weights-=((1/epoc)*Dw_layer2)
                self.layer3.weights-=((1/epoc)*Dw_layer3)

                self.layer1.bias-=((1/epoc)*Db_layer1)
                self.layer2.bias-=((1/epoc)*Db_layer2)
                self.layer3.bias-=((1/epoc)*Db_layer3)

So far I have tried to implement this as shown above. But there seems to be a mistake because, after training, the network doesn't seem to have learned. Please let me know if you have any inputs.

The back propagation must be done in two steps.

Transfer derivative

Given the output value, you must calculate its slope. This is simple as you are using the sigmoid activation function. So the derivative can be calculated as follows

# Calculating slope
def transfer_derivative(output):
    return output * (1.0 - output)

Back propagate the error

Calculate the errors for the various layers of the network and update the weights and bias.

# Error calculation

# For output layer
error = (expected - output) * transfer_derivative(output)

# Hidden layers
error = (weight_k * error_j) * transfer_derivative(output)

Where error_j is the error signal from the jth neuron in the output layer, weight_k is the weight that connects the kth neuron to the current neuron and output is the output for the current neuron.

And finally updating weights

weight = weight + learning_rate * error * input

Here is a detailed explanation of implementing neural networks from scratch using Python along with sample code. Give it a read.


What is artificial intelligence? What is the definition of artificial intelligence?

Over the years, many people attempted to define artificial intelligence. A lot of those definitions are summed up by Stuart Russell and Peter Norvig in their book Artificial Intelligence - A Modern Approach

The definitions of AI can be summarised as falling into the following categories:

  Those that address thought process and reasoning (how an AI thinks/reasons)
  Those that address behaviour (how an AI acts given what it knows)

Furthermore, the above 2 categories are further divided into definitions that:

  I. assess the success of an AI (to do the above) based on its ability
  to replicate human performance

  II. or an ability to replicate an ideal performance measure called
  'rationality' (does it do the 'right' thing based on what it knows?)

I will cite you definitions that fit into each of the above categories:

  1.I. "The [automation of] activities that we associate with human thinking, activities such as decision making, problem solving, learning.." - Bellman 1978
  1.II. "The study of the computations that make it possible to perceive, reason, and act." - Winston, 1992
  2.I. "The study of how to make computers do things at which, at the moment, people do better" - Rich and Knight, 1991
  2.II. "The study of the design of intelligent agents" - Poole et al., 1998

In summary, AI is devoted to the creation of intelligent and rational machines that can make rational decisions and take rational actions.

I would suggest you read up on the Turing test, which Alan Turing proposed to test if a computer was intelligent. However, the Turing test has a few issues, because it is anthropomorphic.

When Aeronautical engineers created the airplane, they didn't set their goal that planes should fly exactly like birds, but rather, they started learning how lift forces were generated, based on the study of aerodynamics. Using this knowledge, they created planes.

Similarly, people in the AI world shouldn't put, IMHO, human intelligence as the standard to strive for, but, rather, we could use, say, rationality as a standard (amongst others).

Intelligence

A measure of the strength of a decision-making agent relative to other decision-making agents, in regard to a given task or set of tasks. The medium is irrelevant—intelligence is exhibited by both organic and intentionally created mechanisms.  May also be the capability to solve a problem, as in the case of a solved game.

Artificial

Relates to the term artifact, a thing which is intentionally created.  Typically this term has been used to connote physical objects, but algorithms created by humans are also regarded as artifacts.

The etymology is derived from the Latin words ars and faciō: "To skillfully construct", or, "the art of making".

Artificial Intelligence

Any decision-making agent that is skillfully (intentionally) constructed.

APPENDIX: The meaning of "intelligence"

The original meaning of "intelligence" seems to be "to acquire", back to the Indo-European. See: intelligence (etymology); *leg/*leh₂w-

The OED 1st definition of intelligence is not incorrect, extending the meaning to acquisition of capability (demonstrable utility), just that the second definition is the older and fundamental: "The collection of information of [strategic] value; 2.3 (archaic) Information in general; news."

You can regard the universe as being comprised of information, whatever form that information takes (matter, energy, states, relative positions, etc.) From the standpoint of an algorithm, this makes sense since the only means they have to gauge the universe are percepts.

Take a flat text file. It may just be data, but you could try and execute. If it actually runs, it might demonstrate utility at some task. (For instance, if it is a minimax algorithm.)

"Intelligence as a measure of utility" is itself "intelligence" in the sense of information, specifically that information by which we measure intelligence, as a degree, relative to a task or to other intelligences.


Machine Learning hardware usage in embedded applications I've been reading a lot about hardware development and implementation for AI/ML, mainly about Deep Learning, and I have a question about its usage.
From what I understand, there are 2 stages for DL: first is training and second is inference. The first is often done on GPUs because of their massive parallelism capabilities among other things, and inference, while can be done on GPUs, it's not used that much, because of power usage, and because the data presented while inferring are much less so the full capabilities of GPUs won't be much needed. Instead FPGAs and CPUs are often used for that.

My understanding also is that a complete DL system will have both, a training system and an inferring system.

My question is that: are both systems required on the same application? Let's assume an autonomous car or an application where visual and image recognition is done, will it have both training system to be trained and an inference system to execute? Or it has only the inference system and will communicate with a distant system which is already trained and has built a database?

Also, if the application has both systems, will it have a big enough memory to store the training data? Given that it can be a small system and memory is ultimately limited.

Deep learning seems mostly to be a buzzword for what is essentially a neural network. You train with a data set to recognize a pattern, then input new data which is then classified by the trained network.

So you train a neural network with 10 different kinds of animals using thousands of pictures. Then you show the network say 100 new images and have the network "guess"  what each animal is.

The point here is that training a neural network would required code for feedback that an application using the trained network would not need. So an application just using the trained network would be a bit more streamlined than an application which could allow additional training data.

What is missing is the ability for machine learning to form hierarchical or otherwise interrelated rules from the trained network so that the trained network is closer to being able to rationally explain why the classification works. Going back to the 10 animal trained network, without formulation of rules during training, there is no practical way for the network to reveal why any of the animals was classified the way it was.

To answer your question: Training and inference are usually completed on two separate systems you are right in knowing that training of deep neural networks is usually done on GPUs and that inference is usually done on CPUs. However, training and inference are almost always done on two separate systems. The main workflow for many data scientists today is as follows:
1. Create and establish all hyper-parameters for a model such as a deep neural network
2. Train the deep neural network using a GPU
3. Save the weights that training on the GPU established so that the model can be deployed.
4. Code the model in a production application with the optimal weights found in training.

So as you can see from this workflow training and inference are done in two completely separate phases.

However, in some specific cases training and inference are done on the same system. For example, if you are using a Deep Neural Network to play video games than you may have the neural network train and infer on the same system. This would lead to more efficiently because it would allow the model to continuously learn.

To answer your question on memory, the only applications where inference and training are done in the same application have a lot of memory available(think dual GPU dual CPU 128gb of RAM workstations) whereas applications that have a limited amount of memory only use inference such as embedded applications.


How to train a logical XOR with reinforcement learning? After reading an excellent BLOG post Deep Reinforcement Learning: Pong from Pixels and playing with the code a little, I've tried to do something simple: use the same code to train a logical XOR gate.

But no matter how I've tuned hyperparameters, the reinforced version does not converge (gets stuck around -10). What am I doing wrong? Isn't it possible to use Policy Gradients, in this case, for some reason?

The setup is simple:

3 inputs (1 for bias=1, x, and y), 3 neurons in the hidden layer and 1 output.
The game is passing all 4 combinations of x,y to the RNN step-by-step, and after 4 steps giving a reward of +1 if all 4 answers were correct, and -1 if at least one was wrong.
The episode is 20 games

The code (forked from original and with minimal modifications) is here: https://gist.github.com/Dimagog/de9d2b2489f377eba6aa8da141f09bc2

P.S. Almost the same code trains XOR gate with supervised learning in no time (2 sec).

Reinforcement learning is used when we know the outcome we want, but not how to get there which is why you won't see a lot of people using it for classification (because we already know the optimal policy, which is just to output the class label). You knew that already, just getting it out of the way for future readers!

As you say, your policy model is fine - a fully connected model that is just deep enough to learn XOR.  I think the reward gradient is a little shallow - when I give a reward of +1 for "3 out 4" correct and +2 for "4 out of 4", then convergence happens (but very slowly).

Maybe Deep Reinforced Learning?

I am not sure but AND gate could be solved by your implementation. I have other feeling with OR gates. Just think - first we need to have information about two conditions and then we can check for complex solutions.
First of all I thought about Neural Network with one hidden layer. Sounds perfect.

I think you will understand when you check this Tensorflow-Keras code:

iterations = 50

model = Sequential()
model.add(Dense(16, input_shape=(None, 2), activation='relu')) # our hidden layer for OR gate problem
model.add(Dense(2, activation='sigmoid'))
model.summary()
opt = Adam(0.01)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['acc'])
# mean_squared_error categorical_crossentropy binary_crossentropy

for iteration in range(iterations):
    x_train = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # table of inputs
    y_train = np.array([[1, 0], [0, 1], [0, 1], [1, 0]]) # outputs in categorical (first index is 0, second is 1)

    r = np.random.randint(0, len(x_train)) # random input
    r_x = x_train[r]
    r_x = np.array([[r_x]])
    result = model.predict(r_x)[0] # predict
    best_id = np.argmax(result) # get of index of "better" output

    input_vector = np.array([[x_train[r]]])
    isWon = False
    if (best_id == np.argmax(y_train[r])):
        isWon = True # everything is good
    else:
        # answer is bad!
        output = np.zeros((2))
        output[best_id] = -1
        output = np.array([[output]])
        loss = model.train_on_batch(input_vector, output)

    print("iteration", iteration, "; has won?", isWon)

When "answer" of agent is good - we are not changing anything (but we could train network with best action as 1 for stability).

When answer is bad, we set action as bad - other actions have more probability for be chosen.

Sometimes learning need to have more than 50 iterations but it is only my proposition. Play with hidden layer neuron count, learn rate and iterations.

Hope will help you :)


What is the proof that the branch and bound algorithm always finds optimal path in a graph? I've been studying Branch and Bound's graph algorithm and I hear it always finds the optimal path because it uses previously found solutions to find others

However, I haven't been able to find a proof of why it finds the optimal path. (In fact, most sites kind of do a bad job generalizing the algorithm itself.)

What is the proof that this algorithm always finds the optimal path in the case of a graph with 1 or more goal nodes?

Branch and Bound is similar to an exhaustive search, except it incorporates a method for computing lower bounds on branches. If the lower bound on a given branch is greater than the upper bound on the problem (i.e. the current best solution encountered), that branch can be discarded since it will never produce an optimal solution.

Hence, since you explore all options except those you know will produce values less optimal than your current best value, you are guaranteed to encounter the global optimum.

Note this is a generic algorithm, and you will need to reference a specific implementation if you want proof of why it satisfies these criteria.

My attempt was proof by contradiction. We can assume B&B found a sub-optimal path, but that would create a contradiction, because the only way B&B would miss an optimal path is if it skipped it completely (this part I don't know how to prove) or the related part of the search space was pruned.


Does replacing 3x3 filters with 3x1 and 1x3 filters improve the performance? Recently I have come up with a VGG16 model for my binary classification task. I have relatively simple signal images

Therefore (maybe?) other deeper models like resnet18 and Inceptionv3 were not as good. As known, VGG uses 3x3 filters for convolving the images to make feature maps. I have tried several hyper-parameters to get a desired performance. However, there are still some things I need to do. I was thinking of replacing the 3x3 conv filters with 3x1 followed by 1x3 filters to reduce the compute. I think it will definitely do so considering the multiplications (9 operations for 3x3and 6 for 3x1 followed by 1x3).
Then I came to think: If I replace all the 3x3 filters with separable filters, will I get any performance improvement?
What are the benefits of replacing 3x3 filters with separable ones?
Thanks

If the filter is separable, that is, the NxM kernel can be mathematically equal to the convolution of a Nx1 filter and a 1xM filter, there are a very important increase in performance.
Using separable convolution, the network can made an optimal usage of the shared memory and of the parallelism in memory access. See this excellent article for details. These improvements are bigger for bigger kernels.
Also the training is improved, starting by the simple fact that a NxM filter has a number of parameters proportional to N*M but the related separable one has N+M.

First of all, Keep in mind that maths operations aren’t the only thing that contribute to performance. Memory bandwidth can also be a factor.
And most importantly, we want to capture as much area as we can in lowest possible number of operations. So in 3x3 kernel case, we can capture 9 cells in one shot, but with 3x1 followed by 1x3, we have to compute 6 times to capture 9 cells. Which clearly states that 3x3 kernel is far more efficient than these two sequential kernels.
So, answer to your question will be no, it will not improve performance, instead it will increase computation overhead for your system.


If we want to classify something as either a cat/dog or neither, do we need 2 or 3 classes? Suppose one trains a CNN to determine if something was either a cat/dog or neither (2 classes), would it be a good idea to assign all cats and dogs to one class and everything else to another? Or would it be better to have a class for cats, a class for dogs, and a class for everything else (3 classes)? My colleague argues for 3 classes because dogs and cats have different features, but I wonder if he's right.

If you want to determine if something is either a

cat/dog or neither

you need 2 classes:

one for dog or cat, and
one for anything else.

However, if you assign all cats and dogs to the same class $A$, if an input is classified as $A$, then you won't be able to know whether it is a dog or a cat, you will just know that it is either a dog or a cat.
In case you wanted to distinguish between cats and dogs too (apart from neither of them), then you'll need $3$ classes.
Finally, if you specify only 2 classes:

dog, and
cat,

then your CNN will try to classify any new input as either a dog or a cat, even though it is neither a dog nor a cat (e.g. maybe it is a horse).

Normally you only have two classes along with a threshold probability.
It's how systems like YOLO work.


How to classify this environment? Consider an environment, where an agent intends to move from cell "A" to cell "G", avoiding obstacles (cells marked with shading). The agent can move forward, rotate 90º to the left, or rotate 90º to the right, and can identify the type of cell in front of him. Here's a diagram.

Classify the characteristics of the environment, according to:

Accessible or non-accessible
Deterministic or non‐deterministic
Episodic or non‐episodic
Discrete or continuous
Static or dynamic

The environment is :

Deterministic : the future state of the environment (and the agent) is defined by the agent's action.
Partially Observable (partially accessible) : since his sensors don't see what's beyond the shaded barrier, the environment is partially observable (accessible).
Sequential (non-episodic): Since the agent's current action will constrain and affect the space of possibilities (options, choices) of future actions, current decisions are not independent of future ones.
Discrete : Environment is not continuous, that is, every action/step/case is finite (either turn left, right, forward or backward), you don't have other actions, which makes it a discrete task environment.
Static : the environment is not changing, it's static, only the agent is moving.


Is gradient descent scale invariant or not? I know we should scale the input and output (assuming regression task) before we feed it to the neural network. Then the gradient descent will give the better minima much faster. But I have subtle confusion whether gradient descent with feature scale and without feature scale gives the same result or just gradient descent is not scale-invariant.

What are you hoping to get out of the answer for this question?
Feature scaling is a method you CAN(but don't have to) use, so that your algorithm performs faster and reaches better general accuracy.
I would say that on a simple regression task, where the feature value ranges do not vary a lot, the output would probably be almost the same, but as soon as you introduce data that has one feature of range 1-10, and other range of 10000-100000, that is where you would notice that you NEED to standardize/normalize your features in order to reach optimal results.
That's why it's almost a general rule to just scale your data, so your algorithm can generalize better, and you don't have to worry about your algorithm giving higher importance to a feature with higher values, instead of the one with lower values(just an example).


Can ELMO embeddings be used to find the n most similar sentences? Assume I have a list of sentences, which is just a list of strings. I need a way of comparing some input string against those sentences to find the most similar. Can ELMO embeddings be used to train a model that can give you the $n$ most similar sentences to an input string?

For reference, gensim provides a doc2vec model that can be trained on a list of strings, then you can use the trained model to infer a vector from some input string. That inferred vector can then be used to find the $n$ most similar vectors.

Could something similar be done, but using ELMO embedding instead?

Any guidance would be greatly appreciated.

I ended up finding this article which does what I'm looking for.
Below is the portion of code I adapted for my needs

from sklearn.metrics.pairwise import cosine_similarity

import tensorflow_hub as hub
import tensorflow as tf

elmo = hub.Module("https://tfhub.dev/google/elmo/2", trainable=True)

def elmo_vectors(x):
  embeddings=elmo(x, signature="default", as_dict=True)["elmo"]

  with tf.device('/device:GPU:0'):
    with tf.Session() as sess:
      sess.run(tf.global_variables_initializer())
      sess.run(tf.tables_initializer())
      # return average of ELMo features
      return sess.run(tf.reduce_mean(embeddings,1))

corpus=["I'd like an apple juice",
        "An apple a day keeps the doctor away",
         "Eat apple every day",
         "We buy apples every week",
         "We use machine learning for text classification",
         "Text classification is subfield of machine learning"]

elmo_embeddings=[]
print (len(corpus))
for i in range(len(corpus)):
    print (corpus[i])
    elmo_embeddings.append(elmo_vectors([corpus[i]])[0])

print ( elmo_embeddings, len(elmo_embeddings))
print(elmo_embeddings[0].shape)
sims = cosine_similarity(elmo_embeddings, elmo_embeddings)
print(sims)
print(sims.shape)

I'm assuming you are trying to train a network that compares 2 sentences and give how similar they are.

To do that you will need the dataset (the list of sentences) and a corresponding list of 'correct answers' (the exact similarity of the sentences, which I'm assuming you don't have?).

Why do you need to compare them using a neural network though? For python, difflib's sequence matcher would be my suggestion, but I'm sure there are many other libraries out there :)


Is consciousness necessary for any AI task? Consciousness is challenging to define, but for this question let's define it as "actually experiencing sensory input as opposed to just putting a bunch of data through an inanimate machine." Humans, of course, have minds; for normal computers, all the things they "see" are just more data. One could alternatively say that humans are sentient, while traditional computers are not.

Setting aside the question of whether it's possible to build a sentient machine, does it actually make a difference if an AI is sentient or not? In other words, are there are tasks that are made impossible - not just more difficult - by a lack of sentience?

No-one knows.

Why: because it's not possible to formally determine even whether your fellow human beings are actually conscious (they may instead be what is philosophically termed a 'Zombie'). No test known to modern physics suffices to decide. Hence it's possible that you are the only sentient being, and everyone else is a robot.

Consequently, we cannot determine which tasks require sentience.

Note that the ontological status of Zombies is controversial: some philosophers of AI (e.g. Daniel Dennett) claim that Zombies are logically impossible while others such as David Chalmers would claim that a Zombie would be compelled to assert that they experience qualia (i.e. are sentient) even though they do not. Here is a very readable paper by Flanagan and Polger that also explains why a stronger neurological version of the Turing test is insufficient to detect a Zombie.

EDIT: In response to the comment about whether an objective test for distinguishing sentience from non-sentience exists:

No-one knows. What we do believe is that this would require something in addition to what modern physics can currently tell us. David Chalmers has speculated that qualia should be introduced as a new form of physical unit, orthogonal to the others in the same way that electrical charge is orthogonal to distance.

In the absence of an objective test, we have to rely on Turing test variants, which no more guarantee consciousness in the subject than they do intelligence.

A being without sentience cannot suffer. If, for example, we wanted to take joy in the suffering of another, only an AI that was sentient would suffice.

Suppose we had some sadists who could not be satisfied or productive unless they got to produce lots of suffering. And say we only cared about minimizing human and animal suffering. What we would need for this job is something non-human and non-animal that could suffer. A conscious AI would do, a non-conscious one would not.

The claim was made in the comments that consciousness cannot be proven, other than perhaps by introspection. But clearly this is not a problem since sadists take joy in torturing others, and those others cannot prove they're conscious either.


What is a learning agent? What is a learning agent, and how does it work? What are examples of learning agents (e.g., in the field of robotics)?

A learning agent is any entity that, over time, improves its performance (which can be defined in different ways depending on the context) based on the interaction with the environment (or experience).

The human is an example of a learning agent. For example, a human can learn to ride a bicycle, even though, at birth, no human possesses this skill.

What is a Learning Agent?

A Leaning Agent is a tool in Artificial Intelligence, that is capable of learning from its experiences. It starts with some basic knowledge and is then able to act and adapt autonomously, through learning, to improve its own performance.

Lets take an example of Uber taxi,hope you know how Uber works....I do think this common example will as well help you get it right away.

Imagine you've decided to start driving for Uber. It's a Friday night and you're running your typical route from the nightlife in San Francisco to many of the hotels away from the downtown area.
You've become accustomed to taking the Cupertino Street via Apple headquarters,exit to pick up your Engineers, but tonight you opt for Mountain View Road via Google headquarters for a change of pace. To your surprise, you discover that Mountain View Road is not only quicker, but you can avoid the accidents prone intersection at Cupertino Street and other Bay Area street . You decide that, in the future, you'll be sure to take Mountain View Road.

Having said that, a learning agent is able to act and adapt basing on new information. The more it learns the better to make effective decisions.

This can be traced from real world self driving cars,which are incorporated with sensor data processing in an Electronic Control Unit(ECU),Ladars....etc.

Hope this can give you some insight.


Recent methods for Decision Support System (DSS) In Decision Support System (DSS), we rank items based on predetermined weighted criteria. For example, we want to rank prospective programmers based on their working experience, required salary, set of skills, age, etc. We rank using weights for each criterion that we have previously defined. The simplest method is using Simple Additive Weighting (SAW).
As far as I know, DSS is included in knowledge-based AI (it's a mandatory subject in AI specialization in most universities in my country).
My question:

With the development of AI/ML/DL today, is there another modern approach that can be used to solve similar problems?

At first, I thought it's similar with Content-Based Recommender System, but it looks different as we don't have "user" in DSS.

In my opinion, the sucess level of the Deep Learning models is perfectly suited for DSS. For example, if you have data you can built perfect Deep Reinforcement Model to rank programmers. In general AI models, specifically Deep models, are not mature enough to use without supervision of human being. But they are very suitable to build support systems.


Is there a mathematical theory behind why MLP can classify handwritten digits? I'm trying to really understand how multi-layer perceptrons work. I want to prove mathematically that MLP's can classify handwritten digits. The only thing I really have is that each perceptron can operate exactly like a logical operand, which obviously can classify things, and, with backpropagation and linear classification, it's obvious that, if a certain pattern exists, it'll activate the correct gates in order to classify correctly, but that is not a mathematical proof.

The approximation theorem says you can approximate anything. But this is kind of meaningless in so far as you can do KNN and get an arbitrary approximation of your training data also.

Proving CNN correctly extract features is, I don't think possible. Or if it is, something involving VC theory is probably the best you can do.


Could a large number of interconnected tiny turing-complete computer chips be patterned across a wafer to simulate a programmable neural network? The Intel 8080 had 4500 transistors and ran at 2-3.125 MHz. By comparison, the 18-core Xeon Haswell-E5 han 5,560,000,000 transistors and can run at 2 GHz. Would it be possible or prudent to simulate a neural network by backing a chip chock-full of a million interconnected, slightly modified intel 8080s (sped up to run at 2 GHz)? If each one modeled 100 neurons you could simulate a neural network with 100 million neurons on a single chip.

Edit: I'm not proposing that you actually use a million intel 8080s; rather I'm proposing that you take a highly minimal programmable chip design like the intel 8080's design and pattern it across a wafer as densely as possible with interconnects so that each instance can function as one or a few dozen fully programmable neurons each with a small amount of memory. I'm not proposing that someone take a million intel 8080s and hook them together.

It's been done (essentially). This guy at the following link has used a series of FPGAs to emulate hundreds of 8080s, using them to train a neural network to play Gameboy games.
https://towardsdatascience.com/a-gameboy-supercomputer-33a6955a79a4

IBM's True North being used in Darpa's SyNAPSE program is also very close to what you suggest. https://en.wikipedia.org/wiki/TrueNorth

Also of interest may be SpiNNaker and Intel Loihi.

Theoretically it might be possible but practically it is not.

You can argue by using the analogy of a Turing machine. You can say that the Intel 8080 is a turing machine hence it can run any program including a neural network given infinite time and memory.

Inspite of the above you will face insurmountable challenges in implementing your system.

CPU's are designed to handle calculations in a sequential manner, most AI algorithms are distributed. You need a GPU (or an AI ASIC) to process the algorithms  in a massively parallel manner for a significant speedup.

Additionally GPU's are excellent at floating point math, floating point arithmetic involves numbers with a variable number of decimal places which are key in running neural networks. For example an Intel core i7 6700k is capable of 200 Giga-FLOPs (floating point operations per seconds) while on the other hand an NVidia GTX 1080 GPU is capable of about 8900 Giga-FLOPs which is a significant difference. (Tyler J 2017)

If you decide to use the intel 8080 (0.290 MIPS at 2.000 MHz), you will require millions of processors and billions of dollars just to compute at one gigaflop. You can follow this link to see the cost of computing over the years https://en.wikipedia.org/wiki/FLOPS

Another problem concerns RAM. To efficiently run a neural network you need to fully load it in RAM. It will be a huge challenge to squeeze a neural network in the 64 Kb of RAM that an Intel 8080 processor offers.

The network bandwidth problem will also be a huge bottleneck. Modern GPU's support high speed technology to communicate between the GPU's. For example NVidia's NVLink has a peak speed of around 80 GBps. While  PCI-E 3.0 runs at around 30 GBps. Without a high speed interconnection bandwidth you will not achieve any speedup inspite of using a distributed system with many processors.

Additionally you will face significant challenges in programing neural network algorithms for your 8080 processor based system. Most programmers today follow the standards of object oriented programming which enables code reuse, simplified design and maintanance. Besides, OOP languages such as Java, C++ and Python have libraries that significantly simplify the process of programming a neural network.

When the 8080 processor was designed back in 1974 OOP had not yet been concieved, they were also using programming tools i.e. compilers that would be considered archaic with todays standards. I mean good luck debugging that system.

Last but not least, you need big data (or atleast a substantial dataset) to train your neural network on. Without training on a big data set your model will be ineffective. The 8080 supported around 200 Kb of storage. For comparison the MNIST dataset is around 14 GB in size. This means that your processor cannot support the neccessary storage of any ML dataset.

For the above reasons my conclusion is that the 8080 processor provides insufficient resources necessary to implement any effective DL algorithm. Networking millions of them together will not provide any substantial speedup for a DL algorithm.


Do AlphaZero/MuZero learn faster in terms of number of games played than humans? I don't know much about AI and am just curious.
From what I read, AlphaZero/MuZero outperform any human chess player after a few hours of training. I have no idea how many chess games a very talented human chess player on average has played before he/she reaches the grandmaster level, but I would imagine it is a number that can roughly be estimated. Of course, playing entire games is not the only training for human chess players.
Nonetheless, how does this compare to AI? How many games do AI engines play before reaching the grandmaster level? Do (gifted) humans or AI learn chess faster?

According to Table S3 of the AlphaZero paper (p. 15)

AlphaZero was trained for 9 hours and, during these 9 hours, it played 44 million games of chess.
According to this Wikipedia article, the longest human lifespan is that of Jeanne Calment, who lived to age 122 years and 164 days.
Let's assume that humans cannot live more than 123 years (which is a reasonable assumption, although this record could eventually be broken). Let's also assume that a chess game lasts at least 10 minutes, which means that you can play at most 6 games in 1 hour, which means that you can play at most $6*24 = 144$ games in one day (assuming that you never sleep, which is, of course, impractical, but I'm just trying to show you an upper bound). Let's say that a year has 365 days. So, here is roughly the maximum number of games that a human could play
$$
6*24*365*123 = 6464880 \tag{1}\label{1},
$$
which is smaller than 44 million games by a factor of more than 6, i.e. any human could at most play 1/6 of the games that AlphaZero played, and \ref{1} is a very loose upper bound that doesn't take into account that humans need to sleep, eat, and do many other things.
So, humans learn to play chess a lot slower than AlphaZero. This is not surprising at all, given that computers can perform calculations a lot faster than us (that's why they are called computers), and this has been the case for many years. We (humans) just made computers make the right calculations for them to approximately play chess better than us. That's it.

A simple Google search such as https://www.quora.com/How-many-games-did-Alpha-Zero-played-against-itself-during-its-four-hours-training will tell you about AlphaZero took about 44 million games to achieve in just hours.
No human will of course can do it.


Why do non-linear activation functions not require a specific non-linear relation between its inputs and outputs? A linear activation function (or none at all) should only be used when the relation between input and output is linear. Why doesn't the same rule apply for other activation functions? For example, why doesn't sigmoid only work when the relation between input and output is "of sigmoid shape"?

It is correct to say that a sigmoid activation function would only work well as a model if the desired output is close to the sigmoid function applied to the input.  This is a trivial fact that applies to a single layer perceptron.  This is true for for the single layer case for any activation function, also a trivial fact.

When the layer number is between one and infinity (two or more), the theory bifurcates.  The identity function becomes a special case:  Any number of layers that conform to a first degree polynomial, $ax + b$, can be replaced with a single identity layers.  The alternative case, where there are multiple layers that functionally do not conform to a first degree polynomial, $ax + b$, cannot be replaced by a single layer of some equally simple function.  The complexity increases geometrically, which is the entire point of multilayer perceptrons.

Under particular constraints, the multilayer perceptron can produce a wide variety of functional behaviors that do not resemble the activation functions of the layers.

For instance, a properly trained network using sigmoid activation functions, with sufficient layer depth and sufficient massive allocation of computing resources, could theoretically approximate the topography of the Himalayas.

Because any number of linear layers can be represented by a single linear layer:

$A_2*(A_1*x +b_1)+B_2 = A_2*A_1*x+ A2*b_1+b_2$

The same is not true if you have non-linear functions.


Which marketing-related classification challenges is a feed forward neural network suited to solve? I am trying to think of some marketing-related classification challenges that a feed-forward neural network would be suited for.

Any ideas?

Has a data set been chosen? There's a wide variety of data out there (see this, this, or this).  Analytical possibilities are largely determined by the available data, so choosing your data would probably help to clarify your objectives.