text:
AI in dota2 vs AI in starcraft
I am just curious what AI would be harder to create from a strictly engineering point of view. AI which would win 1vs 1 game with the best player in starcraft or AI which would control a team the whole team in dota2 and win against the best team?

Welcome to Artificial intelligence community.We are a small brilliant community of scientists/geeks and nerds.I would kindly request you to go through community guidelines.and also avoid duplicate questions.Because smart boys are always around to help you out after analysis is done.Big Bless.

@BlindFungFuMaster ,Do you copy,captain. We have reached in the enemy zone.what can we do?

@quintumnia I found the possible duplicate: https://ai.stackexchange.com/q/3814/1671   Still wondering if this question is distinct in that it asks specifically whether "strong narrow" AI controlling multiple game agents would be harder to create than an AI of similar strength controlling a single game agent.  My feeling is that Game Theory and Complexity Theory strongly indicate that the multi-agent controller will be more difficult.  (Although this could be modified if the mechanics for dota2 are significantly less complex than Starcraft.)

@DukeZhou ,So you have analyzed,that it's a duplicated question.Now what  do you do as a community mod?

@quintumnia Similar but not duplicate imo.  This specifically ask which would be harder to produce: an AI controlling a single game play agent, or an AI controlling multiple in-game agents.  The other question asks for distinction, but is not focused on difficulty of the endeavor specifically.

I can't answer definitively without a detailed breakdown of game mechanics of dota2 vs. Starcraft, but assuming the games have similar complexity, the AI controlling multiple in-game agents that form a team would be more complex, and therefore more difficult to create, than a single agent "team".
My supposition is based on the fundamentals of combinatorics and computational complexity:

in dota2, the AI has to not only to identify winning strategies, but coordinate multiple agents.

by contrast:

the Starcraft AI only has to identify a winning strategy, with no coordination between discrete agents which form a team.

Coalitions have traditionally been difficult to analyze in Game Theory and Combinatorial Game Theory (in the latter case especially, restricting mathematical study, for the most part, to games involving only 2 players.)  In this case the issue is not coalitions--the multiple game agents are already on the same team--but complexity is nevertheless dramatically increased by the existence of multiple agents on a team as compared to a team consisting of a single agent.

While it is true that the coordination of several agents is more complex, I don't think this holds true for the question at hand. In Dota2 you have different accounts playing the game, which must be considered building the architecture of the AI. But In Starcraft you have way more individual units playing together on the same map. I don't see why an AI should treat the individual heroes in dota2 differently than the individual units in Starcraft from a strategic standpoint.

@Demento I generalized by assuming the mechanics of both games are of similar complexity (since I'm not very familiar with dota2.)  In Starcraft, there are many decisions, but only one decision-maker (game agent).  In dota2, there are 4 decision-makers.  So the Starcraft AI only has to make one decision at a time, while the dota2 AI has to make 4 decisions at a time.

Thanks for the clarification. Now I understand your point of view!

There are different abilities required for strong play in those two games. Some of them are easier to implement using AI than others. Therefore it is difficult to answer this question in a generic fashion, but we can look at different aspects in detail:

Speed / APM (Actions per Minute)

While both games require a certain speed, SC2 is usually a bit faster because you simply have more stuff to manage (keep building, arranging your units, coordinate attacks on multiple locations). That said, if you want to control the whole team in Dota2 from a single agent, the APM requirements multiply accordingly. In the end it doesn't really matter, because speed is the least of our concerns and can simply be improved by throwing more resources at the problem. So I wouldn't say that one of the two games has an advantage here concerning engineering effort, just wanted to get the topic out of the way.

Implement strong battle technique

Fighting battles is an important skill in both games. While the armies in SC2 are larger, the amount of abilities each unit has is usually smaller. One of the limitations of a human player in SC2 is the inability to control each unit individually, because there are simply too many units most of the time. An AI on the other hand could utilize a complex army significantly better by controlling each unit. I have seen simulations of such armies in the early days of SC2 and it was obvious that no human player can compete with this technique by far.
This aspect is less important in Dota2, because the amount of units is significantly smaller. Nevertheless the precision in executing attacks and retreating could easily be optimized to a level hardly achievable by any human player. I would still rate the potential for super human skill in SC2 much higher because it gets multiplied for each unit.

Find a Winning Strategy

While it is rather easy to beat a human player with speed and technique, finding a winning strategy is a totally different ball game. In games where deception and hidden information plays such a crucial part, the engineering requirements for a strong winning strategy are huge. A strong AI will require a hybrid approach of playing according to programmable rules of different strategies and fine tuning using ML. Both games are still evolving and new (or changing) heroes, units and structures need to be considered in the long run. In my opinion, the hardest part for the AI will be dealing with unconventional or trick plays it hasn't encountered before. SC2 has a higher potential for such trick plays that can catch the opponent off guard and wins you the game right away. And even when the AI has encountered a certain trick play several times, it is very hard to find appropriate counters on its own. So each new trick play will require specific guided training to play correct against it. On the other hand the AI could learn the same tricks and utilize them as part of their strategy.
Dota2 has a smaller range of unpredictable events and strategies, therefore adapting to those would be easier for an AI. This would reduce the engineering effort significantly in this regard.

Limitations

To evaluate the complexity of the problem, you need to consider, which limitations are set in place for the challenge. If you allow the AI to play with unlimited APM, many deficits in strategy can simply be overcome with technique, utilizing pure speed and precision.
If you restrict the challenge to a small map pool, the AI can be trained much more efficiently. If the AI has to be able to navigate arbitrary maps, the problem gets much more complex. The same is true for limiting matchups or hero selection. The more limitations you put in place, the easier it is to implement a strong AI

My conclusion

While it is difficult to weight all those aspects against each other, I feel like it would be easier to implement a strong strategic AI for Dota2 than for SC2, but the leverage of an AI using a strong battle technique is larger for SC2. This doesn't mean a strong Dota2 battle technique can't reach super human level as well, but the skill ceiling is higher in SC2.

It would depend on the level of human authenticity you want to give the AI. For one, in StarCraft II humans are limited by their ability to look at only one particular place in the map at once and of making only one action at a time. Computers aren't necessarily limited by this constraint so you would have to artificially create it. It's a similar story with Dota2 except in this scenario the AI would be able to control all 5 characters at once with precise synchronization which would be unmatched by even the best teams. So again, you would have to artificially created constraints on the agent so that it was forced to optimize for team work and communication. I think a challenging and interesting problem for Dota2 would be to have 5 separate agents working together like humans usually do in the game. It would be interesting to see for example if they could generate a "gaming language" in which to signal cooperative operations on the map as well as setting up ganks and pushes for example. This would give researchers a good environment in which to test how the interactions between separate agents would evolve alongside a common goal.

Great answer.  Welcome to AI!  [I was pondering some of these issues subsequent to my high-level, theoretical answer.  Taking a contrary viewpoint, I wondered if the Starcraft AI needs to be regarded as controlling every non-player-character (NPC) on the map individually, but it occurred to me that, even if that were the case, it makes the decisions one-at-a-time, and does not make decisions for NPCs or groups of NPCs simultaneously, but sequentially]

@DukeZhou In a sense I think that's true and it depends on how the AI in a particular game works. I know for some programmable AIs the engine allows a submission of several actions per 'game step' so you could in practice have many unit's actions per step which would give a significant advantage to machines and programs that can get more actions per step. If however you limit the APM's that the AI can submit then there's another optimization problem available with which actions are the best to submit per game step. Also to note, in SC2 you can submit one game action and influence many units.

Grouping of units would seem to be another factor which raises complexity.  I suspect a definitive answer could only be gotten by comparing the memory and processors utilized in the "strong" dota2 and Starcraft automata, since it would be difficult to mathematically analyze the complexity of the games based on the number of in-game elements and mechanics.


text:
Traveling salesman problem variant: which algorithm to choose?
I have an industrial problem which I'm trying to cast as a Traveling Salesman problem (TSP) in 3D euclidian space. There are physical limitations which implies that some subpaths may or may not be valid based on simple rules.
What algorithm is best to deal with the TSP given that there are rules/model/constraints?
It could be done with Genetic algorithms for example, but the only way i see how to incorporate those rules is by including them somehow within the fitness function. But i feel there should be more suitable approaches.
Would reinforcement Q-learning or other algorithms be more appropriate for a rule-based euclidian TSP?

Probably depends if those rules mean you have O(nodes) recognition, O(nodes) neighbor generation, O(nodes) solution generation, or something else. (I say O(n) but I mean comparative complexity in general)

How many nodes does a typical problem have? Did you consider heuristics tailored to the specific problem?

If you have lots of rules then you should be able to come up with lots of heuristics for A*. If I were you I would try A* first, and come up with as many heuristics as I could. You can also use Deep Q learning. I don't think you want to just throw coordinates into a Deep Q network. You want a simpler representation. I would probably give the nodes symbolic identifiers like sparse matrices, integers or sigmoids, and then craft the loss function to reflect the actual cost of moving from node to node and ascribe a high cost to illegal moves.

source: Stack Exchange

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

sort: votes


text:
Does a bias also have a chance to be dropped out in Dropout layer?
Suppose that you have 80 neurons in a layer, where one neuron is bias. Then  you add a dropout layer after the activation function of this layer.
In this case, does it have a chance to drop out the bias neuron, or does the dropout only affect the other 79 weight neurons?

Only the non-bias ones,
It is discouraged to include the bias weights under norm penalty regularization for example, so why should it be included in the drop-out regularization scheme?
Drop out can be implemented by multiplying units with zero and the bias term is rather special. The bias term determines the distance from the origin the linear decision boundary of the node implements. It is included in every sum, but it does not receive any inputs.
So to take your example, say you have 80 nodes per layer in an MLP, where one is a bias node, the output of these layers will consist of 79 nodes every time. This output is then put under the drop-out effect.
From Goodfellows et al. Deep Learning book under the regularization chapter, present online: "http://www.deeplearningbook.org/contents/regularization.html", they write that they implement the drop-out by canceling some outputs to zero:
"
In most modern neural networks, ... , we can effectively remove a unit from a network by multiplying its output value by zero. ... . Here, we present the dropout algorithm in terms of multiplication by zero for simplicity, but it can be trivially modiﬁed to work with other operations that remove a unit from the network.
"
Drop-out by cancelling outputs, the output from the activation function, has nothing to do with the bias vector. It is not receiving any inputs.
Therefore I think the implementation typically only deals with output-to-input connections, and the bias vector does not receive inputs so it can safely be let alone from the drop-out process.

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


text:
What type of reinforcement learning can I do restricted to ~200MB on an average smartphone?
This concerns a set of finite, non-trivial, combinatorial games [M] in the form of an app. A sample game can be found here.
Because this is a mass market product, we can't take up too much space, and the AI needs to be able to run locally since connectivity cannot be assumed. The current size of the Android kernel is < 7MB.
The goal is not sheer AI strength, but respectable AI strength, sufficient to beat the above-average human player. (The current strongest, weak automata, using a few heuristics, is already capable of beating the average human player.)
Because the games are finite, the gametrees eventually become tractable, allowing for perfect endgames.  Resource stealing strategies and trap-avoidance can also be effected with shallow look-ahead at all phases, and the patterns are much easier for automata to recognize than for humans.
In this context, reinforcement would be mostly utilized to "tune the automata to the style of the human player," and produce different automata on different devices, which could subsequently play against each other as proxies for their human partners.
The game data can be stored efficiently, initially requiring only 2 bytes per position (a value 0-9 and a coordinate 1-81, although the number of coordinates will grow in basic game extensions, and require 2 bytes for larger-order gameboards such as "Samurai" Sudoku.) So the first turn on a given game requires only 2 bytes, the second turn bytes, etc., up to between 50 and 70 turns on an 81 cell gameboard.  Additionally, because it's a square grid, we can reduce for symmetry.  But even with an average number of turns at 50, that's only about 40,000 games for 200MB.

Weighting Openings

My feeling is that reinforcement would be useful in weighting openings.  If the game data is a string, these strings can be compared, and the smaller the sample size (the fewer the turns included,) the more connections there will be. In this case, the sequence doesn't matter, only the set of value/coordinates for a given turn. Abstraction can be utilized in that certain individual value/coordinates are interchangeable. My thought is the automata can weight openings based on how often they lead to desirable outcomes in the form of a win.

Weighting Heuristics

Since we're having good, initial results with heuristics, and these are the most efficient method of decision-making, I'm thinking about weighting evaluation functions so that certain heuristics take precedence under different conditions.  (For instance, when to expand vs. when to consolidate. When to make a choice with immediate benefit over a choice with long-term benefit. Introduction of meta-strategies that modify foundation strategies.)

Database pruning

Because the allocated volume will be capped, it's probably going to be necessary to "prune" the database when info is no longer relevant. (For instance, when a new strategy emerges that renders previous strategies obsolete.) We also probably need a method to help the automata to recognize such situations, so it doesn't persist in potentially obsolete strategies for more than two games without starting to try alternatives.

Q: Can reinforcement learning be meaningfully applied toward these goals under these restrictions?
Q: Are my inclinations for approaching this useful or problematic?
Q: Are there methods I'm not considering that could be applicable under these restrictions?

I just want to point out that training and executing don't have to be done on the same device. E.g. (as far as I know) Tensorflow allows you to train a NN on a powerful machine (e.g. PC with GPUs) and then deploy the trained NN on a much less powerful machine, e.g. an Android phone.

@user12889 That's a great point and you're not the only one to indicate this NN capability.  Part of this initiative will be to see if we can do "mini-NNs" on the local mobile devices, where the local automata get "tuned" by playing against their human, with the intent of leveraging evolutionary game theory (the idea being that each discrete automata is unique do to the "personalization".)  But if we find we need to produce strong AI for an expert-player version of the product, the NN capability you mention will surely be extremely effective!

@DuttaA thanks for the poke.  When I originally asked it, I wasn't even sure how valid of a question it was.  (Luckily, there's been some recent clarification of the approach in terms of the project, where learning algorithms will be the final part, and are still some ways off;)

I skimmed through your question and understood that the state/action space is finite, so in this case, RL would be a good option for storage.
The most basic RL technique will keep track of a matrix Q ∈ ℝs×a, where s is number of possible states, and a is number of possible actions.
In addition to a small overhead of agent's parameters:

α ∈ [0,1] learning parameter
γ ∈ [0,1] discount rate,
ε ∈ [0,1]  exploration rate

If you have a total of 81 states and 10 actions, then your storage would be in the neighborhood of 850 double words.
If your AI will track different states per location, e.g. possible values 0 to 9 + a null, then your state space will grow to 11 * 81 = 968 and the final value matrix will be Q ∈ ℝ968×10 ≈ 20Kb.
Update
I am terrible sorry, I made a terrible mistake in my calculations.
if you are to keep track of 11 possible values in 81 locations, then the correct number should be 1181× double word size, that is a big number.
Of course, if this is Sudoku and you  and you are not considering illegal moves as possible states, then definitely this will be a way smaller number, but you will still keep track of an action space that is as big as the state space.
You might need to use function approximation instead, or some sort of action state space compression.
sorry

Don't apologize!  I really appreciate you taking the time, and this answer is helpful.  Really it's only 9 values over 81 positions, but the game mechanics result with endgame states with ~10 dead cells where no integers can be legally played.  Because of the tractable endgame, we don't need to even go that deep, and merely track openings.

PS I added a slight edit to your first suggestion to the description for the reinforcement-learning tag.  Thanks for getting involved.  If you want to discuss further tweaks, feel free to open a chat, and invite me from a comment here.

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


text:
Is this page of Goodfellow's Deep Learning Textbook missing text?
The textbook Deep Learning by Goodfellow, Bengio, and Courville can be viewed in individual html chapters here.
I'm currently reading Chapter 15 on Representation Learning and saw this for algorithm 15.1 on page 530:

There no condition after end for and similarly no end condition for end if. Is that intentional? If so, what is the correct way to interpret it? I haven't encountered algorithm syntax like this in the past.

There is no industry standard for psuedocode as it is read by humans (for the moment ;) and the author can decide how best to represent the concepts of the algorithm with the aim of balancing precision and understandability. In this case there is a
FOR ... END FOR
block which is iterated over k for 1 to m. And an
IF ... END IF
block that is run if fine-tuning evaluates to true.


text:
Why do knowledge-based agents only add a sentence to the knowledge base when it is 100% sure the sentence is true?
According to Russell and Norvig, a knowledge-based agent will only add a sentence to its knowledge base if it follows logically from what it previously knows, or directly observes. To follow logically essentially means that if the premises are true, then the conclusions are guaranteed to be true. So the agent will only add the sentence if it 100% sure the sentence is true.
Is this hyperskepticism in logic justified? Couldn't the agent be more efficient if it added a sentence if it were 99% sure it were true? It could potentially add a lot more true sentences, and only occasionally add false ones. There would need to be a mechanism for unlearning sentences, but as long as the vast majority of sentences added are true, why couldn't that be done?
I essentially asked this question here, and someone suggested that I post it here.

Great question.  (Please link the Russell and Norvig if you get a chance.)  PS- Welcome to AI!

Mostly because traditional "knowledge based systems" are based purely on deductive logic and that's just the way deduction works.  It only deals with what consequences must follow from the premises.  Traditionally these systems didn't deal with probabilistic knowledge or other less strict forms of reasoning, like abduction.
That said, it is possible to build a knowledge based system that includes probabilistic reasoning, and other reasoning systems (like abduction).
I'll add some more on that point when I have a little more time.


text:
Which government agencies oversee development of new AI?
Nick Bostrom talks in his book Superintelligence about the many dangers of AI. He considers it necessary that strong security mechanisms are put in place to ensure that a machine, once it gains general intelligence far beyond human capabilities, does not destroy humanity (most likely by accident). He describes this as a very delicate process that most likely will go wrong.
Considering that new technologies often neglect the necessary precautions and  that this is highly relevant to national security, I wonder if there are already government agencies overseeing big technology companies like Deepmind. We are currently far away from an intelligence explosion or a technological singularity, but I would assume that governments want to have a foot in the door as soon as they realize and understand the dangers.
So my question is, what government agencies currently investigate and maybe even control AI development? The answer can be general or for a specific country if there is a big difference between countries.

May not be quite what you’re looking for, but nonetheless helpful, I hope. The White House a year ago commissioned a report on AI that touches briefly on policy issues.

Thx for pointing to the report. Yes, not exactly was I was looking for, but an interesting read nevertheless. Upvoted!

Although I (partly) agree with Nick Bostroms view that Artificial Intelligence could in some ways be dangerous. We do not need new government bodies to control or regulate AI development.
We already have sufficient cyber laws that protect us against computer crimes such as cyber terrorism, cyber bulling, creating malware, identity theft, DOSS, unauthorized access e.t.c.  It is the duty of local law enforcement agencies and the FBI to prevent and investigate cybercrimes such as those listed above. Whether AI was used to perpetrate the crime is legally immaterial.
Although AI is a 'new' technology. We already have a rigorous criminal justice system within our governance structures that are well capable of handling any eventualities that may arise from AI or any other technological breakthroughs without being overwhelmed.
For example if an AI causes a car accident the manufacturer of the car can simply be charged for Product Liability for Negligence. If an AI is defective or dangerous. We already have product liability and consumer protection laws and the relevant government agencies to implement them.
If an AI uses its intelligence to maneuver within the law to its own advantage. This by definition is not a crime, big corporations do this all the time to minimize their taxes. However if necessary, the legislature can sit and pass a law criminalizing/banning this new activity.
A sovereign government already has enough powers and the neccessary instruments to excercise that power. Creation of a new government agency will lead to the unneccessary duplication of responsibilities.
The best approach is simply for the relevant government agencies to adapt by playing a proactive role and modernizing their service delivery so that it is in sync with current developments within society.This is what everyone has to do.
In reality we do not need additional agencies. I would find agencies for example Federal Ai Agency
or Federal Blockchain Commission to be baffling and unproductive.


text:
How do cognitive services work?
Currently big tech companies like Microsoft, Google, and Amazon (to name a few) offer cognitive services on their cloud platforms.
With these services it is possible to identify faces, objects, texts, sounds, etc.
Do you know how these services work internally?
The only info I could find was based on the API level. I assume the services use some neural network, which is trained by amounts of data.
In my experience the Google services are more accurate then the Azure services. Perhaps the Google services are better and longer trained?

I found the research papers describing the Vision API from Azure. It also describes their internal workings. https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/research


text:
Are there any load balancing approaches for employee cases based on complexity score?
In working with a social services agency that provides a continuum of programs across the behavioral health and child welfare spectrum the need to adequately manage individual worker and total program caseloads has become increasingly difficult due to burgeoning demand.
Each program has already developed a profile for ranking the complexity of a client based a select number of factors (i.e. diagnosis, previous encounters, results of assessment instruments, etc.).
What we are trying to develop now is an approach to act as a load balancer for new cases to ensure that individual workers' caseloads are balanced with the complexity of cases. We can do this manually to some degree but if there was a way to automate and take the human bias out of it, that is the goal.
Are there are any algorithms or adaptable approaches that have been used to do such a task (even in other sectors)?

I think this is a very good, high-level question on approaches.  (Hopefully it will garner an answer that can point you in the right direction for deep exploration on one of the related AI stacks, such as Data Science.)  Welcome to AI!

Just to clarify, you are asking for an algorithm that takes in a new case, estimates it’s caseload on the average worker, and assigns it to a worker such that no one is over burdened? Is caseload measured in difficulty or in estimates time to complete?

It sounds like you're looking at the Partition Problem. https://en.wikipedia.org/wiki/Partition_problem
The task of slicing one set into N sets so that each set is equal or as close to equal as possible.
Obtaining an exact solution is NP-hard (you can't do much better than trying all combinations), however you can get an approximate answer in polynomial time.
Greedy approach:

Create N sets, each initially empty
Sort all items in descending order (by their complexity score)
for each item add it to the set with the lowest sum

If N is large, you may want to put the sets into a min heap/priority queue.


text:
Is there a name for this principle?
I have an idea for a transformative decision rule (TDR), but I want to know if there's already a name for it.

Any ordinal scale should be converted to a scale such that all  the outcomes are assigned consecutive values.

Let v be the function that assigns values to outcomes (defined as ordered pairs of acts and states).
Let x and y denote any particular such ordered pairs.
Let P be the preference.
Let X+ be the set of all outcomes that are more preferred than x (similarly also for y) X+ in P.

If x in Y+, and x is the closest outcome to y in Y+, then v(x) = v(y) + 1 for all x,y in P.

I could have explained it more formally mathematically, but Latex doesn't seem to render here. If there's no name for it, I'm thinking of "The Law of Consecutive Ordinals (LCO)". As for why I support the rule, it's because it's a rule that needs to be applied to an ordinal scale before I apply an effective decision rule (EDR) that I thought of for ordinal scales. I want to know if there's a name for that principle.

I'd describe this as a Ranking.
However, it's not always possible to distil a set of outcome preferences to a transitive metric, this is one of the central axioms of game theory. The Transitivity Axiom so the problem is relatively well understood (that is, at least, if I've understood your problem)


text:
Is there any way, in which we can monitor what's going on the screen in android to generate a model from it?
I've been working on a project (Android Game), in which the player has to confront with some obstacles/enemies whom he has to destroy. So, is there a way in which we can monitor how the user of the game plays and accordingly to generate (and timely updating) that trained model, which can be used later in the game to make the user think of a different way to defeat an enemy unlike going in the same streamline flow which he has followed till now.
I've implemented Q-Learning and Genetic algorithms on the PC, to make the Game AI for some games like 'tetris' to make the computer play on it's own. But, haven't done it in Android till now.
Already searched: I've also referred to some websites in which they suggested using Neural Networks to encounter the same.
But, I'm unable to get an accurate procedure in which this can be done. Please suggest me a way in which I can monitor the user's input on how he plays.
Thank you.

There seems to be a great deal of emphasis on visual approach to machine learning.  I find this question interesting because it is oriented on the player's tendencies and preferences.  Welcome to AI!

So, is there a way this can be made possible or do we have any tensorflow APIs to proceed with them, I'm really struck with this problem but, I really want to make this project. Please, suggest me..

Unfortunately, all of my work is in highly compact, combinatorial games, not requiring visual learning, so I can't help you with specifics.  But hopefully someone with experience in this area will find your question soon.

Do you want to monitor the user's input in a game you've created (and have the source code) or a game provided by a third party?

User's input... And use that input as my model's input to train the model

The software that you require to provide your AI agent remote access is called Virtual Network Computing (VNC). A VNC is a desktop sharing system that transmits keyboard and mouse movements, over a network connection, from the server (the AI) to the client (training environment).
This allows your AI agent to use a computer like a human does, which is by looking at the screen pixels and operating a virtual keyboard and mouse. Infact VNC's are used conventionally for remote technical support and accessing files on one's computer remotely.
An excellent use case example is Open AI's Universe platform. Alongside Gym, which is Open AI's toolkit for developing RL algorithms. Universe launches programs behind a VNC remote desktop, which enables the training of AI agents by only showing them the screen pixels and allowing them to operate a virtual keyboard or mouse.
Since you want to train your AI agent on an Android based training environment, my suggestion is that you consider installing either Real VNC (android client) or Droid VNC on your Android device. You can then install the VNC server software on your training machine (i.e. an nvidia docker instance). Your AI agent will now have full access to the training environment screen for reinforcement learning.
I also recommend that you look at this similar question on the network.
https://askubuntu.com/questions/414189/how-to-remotely-control-my-android


text:
How does neural network classifier classify from just drawing a decision plane?
I understand that a neural network basically distorts(non-linear transformation) and changes the perspective(linear transformations) of input space to draw a plane to classify data. How does the network deduce if an input is one side of a plane and therefore output the decision? Thanks in advance.

Excellent foundation question.  Welcome to AI!

@DukeZhou Have an idea? XD

I wish.  (All of my work is currently in rules based and axiomatic AI, with reinforcement of heavily bounded rationality still on the horizon.)

If you are working with supervised learning, each training example has a label. That label is your classification of the provided input. Just like linear or logistic regression, if your problem only has 2 classes (e.g. determine whether a tumor is malignant or not), your network will have a single output. An output value of 1.0 could represent one class and an output of 0.0 represents the other. This is basically determining which side of multi-dimensional plane your input is on.
If you have more than 2 (m) classes, then you will have m outputs from your network. Each output will represent the likelihood of the input matching that class. For example if you have an image recognition network that has 4 classes: Dog, truck, boat, person, you would have 4 outputs with each one representing how likely that image is one of the classes. Think about this as 4 independent planes, where each one is making a determination: does this image match this class(1 of {dog, truck, boat, person}) or not. If you had outputs of dog: 0.3, truck: 0.25, boat: 0.7, person: 0.4, One simple algorithm would be simply pick the class with the maximum value -- in this case, it would classify this image as a boat.

Thanks for the answer. After the plane for classification is drawn, what part part of the algorithm determines which side of the place the point lies?

The output could be a single number (binary classification) or a vector (multiple classification) with values from 0 to 1. A threshold comes in place to the first, a threshold is a parameter number [0,1], and you can choice based on the consequences you prefer (see ROC curve), or in the case of the vector you can assign the class of the maximum number. As said Paul, you could pass the output vector for a function, let’s call assign_max_class(output_vector)

For other who were wondering the same questions as me, I'll answer it.
My view above was inconsistent. Ultimately the last layer of simple feed-forward networks don't have any special properties previous layers exhibit. NNs are just glorified mathematical functions. It distorts space with linear(matrix multiplies) and non-linear functions.
Theres no 'decision plane' per-say, only function mappings up to the very end where we want to map the input to (in this case binary classification problem) to two separate numbers (usually 1 or 0).
Hope this clear things up for people getting into NNs.

Yes it is correct. It works on the same basis as any other layer except it it usually uses a special non-linear function that 'sorts' the input into classification categories.

Also, you're right on your assumption, a NN without any hidden layers can preform classification. This network is actually the simple logistic classification algorithm.


text:
What would an implementation of this Neural Network look like?
I'm relatively new to neural networks and was wondering what an implementation of this paper would look like. More specifically, how are the correct values of Kp, Ki, and Kd determined at run time so it can be back propagated?

In the paper there is a diagram of the network showing how there are 3 outputs which share features but have their own set of associated weights. Back propagation works by only looking at one output at a time.


text:
Detect patterns in sequences of actions
I have to analyse sequences of actions that look more or less like this JSON blob. The question I'm trying to answer is whether there are recurring (sub)patterns that different users adopt when asked to perform a certain specific task -- in this case, the task is to build a mathematical formula using this editor. In particular I'd like to know if there are multiple significantly different ways in which people build the same expression.
I thought of creating a Markov model, but that would only give me the most likely sequence of actions of length N. An obvious alternative would be to build trees and count how many times a certain path occurs in the dataset. However, the nature of the expression-building process means that the sequences can be polluted by many confounding, non-significant actions (such as streaks of UNDO-REDO, deleting symbols, and the likes).
I might go the "longest common subsequence" route, but I'm not sure that would tell me if there are "significantly different" ways of building the same expression (in quotes because, for now, I don't have a rigorous definition of "significantly different", but, for example, one way would be to drag and drop-in-place all the symbols in the correct order, and another way would be to drag all the symbols onto the canvas, and then place them in the correct spots).
I thought this might be a nice challenge for some AI algorithm, but I'm quite a noob at that, so I'm open to suggestions.

Thanks for your comment. To answer your questions: (1) Yes, exact matches would be ideal, although I am prepared to drop fields if this improves pattern detection. (2) Ideally exact, but some sequences of actions could lead to the same end result, so, as long as I can control for that / specify what actions can be swapped, I am willing to accept fuzzy matching.

This task falls within the overlapping fields of information extraction and pattern mining. Information extraction involves automatically extracting instances of specified relations from data. While pattern mining involves using data mining algorithms to discover interesting, unexpected and useful patterns between data in databases (Philippe F).
On your question you have stated that you have experimented with markov models with poor results. A better approach if you prefer working with markov models would be to use hierarchical markov models. Hierarchical markov models have multiple 'levels' of states which can describe input sequences at different levels of granularity. Hierarchical markov models are good at categorizing human behavior at various levels of abstraction i.e. a persons location in a room can be further interpreted to determine more complex information such as what activity the person is performing.
However my recommendation is that you implement random forest classifiers for this problem. Random forests provide excellent classification accuracy with a relatively simple implementation. Additionally random forests provide the ability to inspect trees for tweaking parameters to improve accuracy. You can also use cross validation to evaluate your model and calculate its accuracy. Consider using Python's Scikit-learn library's implementation of random forest classifier for this analysis.
In your json code action package you have declared metrics such as DRAG_START, TRASH_SYMBOL, OPEN and CLOSE. My suggestion is that for your model to be accurate you also need to declare lower level actions such as: time between clicks, change in the direction of mouse motion, screen region hover count, task completion time and time between a click and a succeeding mouse movement.
For further reference I recommend that you look at the papers below which I found useful and relevant to your question.
Hierarchical Hidden Markov Models for Information Extraction https://www.biostat.wisc.edu/~craven/papers/ijcai03.pdf
Detecting Abnormal User Behavior Through Pattern-mining Input Device Analytics https://www.ignacioxd.com/files/bib/Dominguez2015-Concentration.pdf
Hierarchical Hidden Markov Model in Detecting Activities of Daily Living in Wearable Videos for Studies of Dementia   https://arxiv.org/ftp/arxiv/papers/1111/1111.1817.pdf


text:
How generate variation in datasets
I building a deep learning model to detect what drug user use. I have many symptoms and duration of each drug. I create X and y data but, for example, LSD have an effect duration of 180 - 720 minutes. I really need make 540 arrays? I really want a help.
My LSD array:
[28, 180],
[28, 720],
[29, 180],
[29, 720],
[30, 180],
[30, 720],
[31, 180],
[31, 720],
[32, 180],
[32, 720],
[33, 180],
[33, 720],
[34, 180],
[34, 720],
[35, 180],
[35, 720],
[36, 180],
[36, 720],
[37, 180],
[37, 720],
[1, 180],
[1, 720],
[38, 180],
[38, 720],
[12, 180],
[12, 720],
[9, 180],
[9, 720],
[24, 180],
[24, 720],
[17, 180],
[17, 720],
[7, 180],
[7, 720],
[4, 180],
[4, 720],

In first position I have differents symptoms and in second position duration. I just duplicated each symptoms and set min duration and max duration. But this return to me a perfection model. I know, I need add all minutes to each symptoms, but how I make this using python?
List of symptoms
0 - relaxamento
1 - euforia
2 - diminuicao da memoria a curto prazo
3 - boca seca
4 - habilidades motoras debilitadas
5 - olhos vermelhos
6 - humor
7 - aumento frequencia cardiaca
8 - aumento apetite
9 - concentracao debilitada
10 - sensacao de poder
11 - ausencia de medo
12 - ansiedade
13 - agressividade
14 - excitacao
15 - perda do apetite
16 - tremores
17 - dilatacao da pupila
18 - dentes anestesiados
19 - insonia
20 - movimentos descontrolados
21 - espasmos maxilar
22 - dor de cabeça
23 - visao turva
24 - nauseas
25 - desidratacao
26 - periodos de depressao
27 - perda total da memoria
28 - ilusões
29 - alucinações
30 - grande sensibilidade sensorial
31 - experiências místicas
32 - flashbacks
33 - paranoia
34 - perda da noção temporal e espacial
35 - confusão
36 - perda do controle emocional
37 - sentimento de bem-estar
38 - pânico
39 - sonolencia
40 - batimentos cardiacos diminuem
41 - insuficiencia respiratoria
42 - desanimo
43 - desinteresse pela vida familiar/profissional
44 - sensacao de estar no paraiso
45 - mal-estar
46 - Incapacidade de sentir prazer
47 - Incapacidade de sentir dor

** Durations effects (in minutes) **
Cannabis. 120 - 240
Cocain. 30 - 40
Ecstasy. 240 - 480
LSD. 180 - 720
Heroin. 45 - 60

My full code:
X = [
    #cannabis
    [0, 120],
    [0, 240],
    [1, 120],
    [1, 240],
    [2, 120],
    [2, 240],
    [3, 120],
    [3, 240],
    [4, 120],
    [4, 240],
    [5, 120],
    [5, 240],
    [6, 120],
    [6, 240],
    [7, 120],
    [7, 240],
    [8, 120],
    [8, 240],
    [9, 120],
    [9, 240],
    #cocain
    [1, 30],
    [1, 40],
    [10, 30],
    [10, 40],
    [11, 30],
    [11, 40],
    [12, 30],
    [12, 40],
    [13, 30],
    [13, 40],
    [14, 30],
    [14, 40],
    [15, 30],
    [15, 40],
    [7, 30],
    [7, 40],
    [16, 30],
    [16, 40],
    [17, 30],
    [17, 40],
    [18, 30],
    [18, 40],
    #ecstasy
    [19, 240],
    [19, 480],
    [20, 240],
    [20, 480],
    [21, 240],
    [21, 480],
    [22, 240],
    [22, 480],
    [23, 240],
    [23, 480],
    [24, 240],
    [24, 480],
    [25, 240],
    [25, 480],
    [26, 240],
    [26, 480],
    [27, 240],
    [27, 480],
    [15, 240],
    [15, 480],
    #LSD
    [28, 180],
    [28, 720],
    [29, 180],
    [29, 720],
    [30, 180],
    [30, 720],
    [31, 180],
    [31, 720],
    [32, 180],
    [32, 720],
    [33, 180],
    [33, 720],
    [34, 180],
    [34, 720],
    [35, 180],
    [35, 720],
    [36, 180],
    [36, 720],
    [37, 180],
    [37, 720],
    [1, 180],
    [1, 720],
    [38, 180],
    [38, 720],
    [12, 180],
    [12, 720],
    [9, 180],
    [9, 720],
    [24, 180],
    [24, 720],
    [17, 180],
    [17, 720],
    [7, 180],
    [7, 720],
    [4, 180],
    [4, 720],
    # Heroin
    [39, 45],
    [39, 60],
    [29, 45],
    [29, 60],
    [40, 45],
    [40, 60],
    [41, 45],
    [41, 60],
    [42, 45],
    [42, 60],
    [43, 45],
    [43, 60],
    [44, 45],
    [44, 60],
    [12, 45],
    [12, 60],
    [45, 45],
    [45, 60],
    [46, 45],
    [46, 60],
    [1, 45],
    [1, 60],
    [13, 45],
    [13, 60],
    [24, 45],
    [24, 60],
]
"""
    # DROGAS

    0 - Cannabis
    1 - Cocain
    2 - Ecstasy
    3 - LSD
    4 - Heroin
"""
y = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
]

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.5)

from sklearn import tree
my_classifier = tree.DecisionTreeClassifier()

my_classifier.fit(X_train, y_train)

predictions = my_classifier.predict(X_test)

print(predictions)

from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, predictions))

Sorry for my bad english :(
Thanks

If you are actually using a deep learning model, with the amount of training data you have provided, it will very easily overfit. Simpler algorithms would be better for this like the decision tree you are using in your python code.

This sounds like regression problem to me.

I have many symptoms and duration of each drug. I create X and y data
  but, for example, LSD have an effect duration of 180 - 720 minutes. I
  really need make 540 arrays?

You can (in this particular case, it's fairly easy to generate ~800 rows in CSV once), but you don't have to: you an apply data augmentation on the fly. This will add some randomness in your training, but it usually helps generalization.
By the way, it seems you aren't actually using deep learning, but rather DecisionTreeClassifier, which is a bit different.


text:
Is there any free dataset of source code along with natural language description?
I am currently working on my MSc thesis, where I try to automatically convert description of an algorithm in natural language to source code in Python (the algorithms are quite simple, like revert an array of 100 elements) using deep learning. The main problem is that I need a lot of data to do that. Does anyone know any available datasets consisting of pairs {short natural language description, source code}?
I know the Heartstone cards dataset (really useful and close to my needs, but still not enough), the Django dataset (Django code commented line by line - it doesn't really contain the description of whole algorithm, it rather translates english to Django code line by line). I tried to contact with few sites like for eg. Sphere Online Judge but to no avail.
Every help would be appreciated.

StackOverflow answers with code snippets. This data needs some processing, because the description can be in the question (along with other notes) and along with the answer. But this dataset is very big.
Also take a look at CodeReview questions.


text:
Can anybody explain such behavior of accuracy and loss of my Net(caffe)?
I used this project for example(framework - caffe, arhitecture of net - mod of AlexNet, 400 images are used for training). I have this result:

or this:

Solver:
net: "./CDNet/Models/train.prototxt"
test_iter: 500
test_interval: 500
base_lr: 0.001
lr_policy: "step"
gamma: 0.1
stepsize: 100000
display: 50
max_iter: 450000
momentum: 0.9
weight_decay: 0.0005
snapshot: 10000
snapshot_prefix: "./CDNet/Models/Training/cdnet"
solver_mode: GPU

Model of net:

Can anybody explain such behavior of accuracy and loss of my Net? What I am doing wrong?
Author of tutorial has got this result:


text:
Is overfitting always a bad thing?
DNN can be used to recognize pictures. Great. For that usage, it's better if they are somewhat flexible so as to recognize as cats even cats that are not on the pictures on which they trained (i.e. avoid overfitting). Agreed.
But when one uses NN as a replacement for numerical tables in an Air Collision Avoidance System (ACAS), it is primarily to reduce the "required storage space by a factor of 1000". For this usage, what we want from the NN is to say "take a slight left turn" or "turn right hard" if another ship comes slightly close on the right or rapidly close on the left, respectively.
For this usage, where the answer is much simpler than recognizing a cat, isn't overfitting a good thing? What would overfitting "look like" in this case and why would it be bad ?
This question somewhat relates to this one, where a general idea seems to be "Machine Learning is used for intractable things, you don't need ML for tractable things". And while it is quite correct that ACAS can be implemented without NN, I wouldn't call NN "useless" for ACAS, because a factor 1000 reduction in required space will always come in handy.

Typically the ramification of overfitting is poor performance on unseen data. If you're confident that overfitting on your dataset will not cause problems for situations not described by the dataset, or the dataset contains every possible scenario then overfitting may be good for the performance of the NN.

Is overfitting always a bad thing?

The answer is a resounding yes, every time. The reason being that overfitting is the name we use to refer to a situation where your model did very well on the training data but when you showed it the dataset that really matter(i.e the test data or put it into production), it performed very bad. This can never be good, because we write models so that they can predict with high accuracy on the datasets it has not seen before. No one cares about a model that got 100% accuracy on the training set and gets 0% on the test set. This is a useless model. We train models so that they can predict with high accuracy on data it has never seen before.
Now for the long answer:
I will start by giving a quick explanation of what overfitting is. Then how we can detect overfitting, this will help me explain why overfitting is allways a bad.
What is overfitting:
In machine learning problem there is signal then there is noise. Signal is the true underlying pattern that you wish to learn from the data whist noise is the irrelevant information or randomness in a dataset.
The reason that leads to overfitting is that your model is making use of "Noise" to make decisions instead of using the signal. Overfitting means that your model performs very well on the training data and performs very poorly on unseen dataset(s) (notice that we pretty much don't care how well a model performs on the training data, we care about how it will perform on data it hasn't seen before). A model that has overfitted is similar to a student who got 100% on the quiz he/she did in preparation for the exam and will get a very poor mark on the exam because he/she because he chose to cram/memorize the quiz's answers and questions instead of understanding how to get to those answers. Another way of thinking about this is that your model has memorized/crammed instead of learning the learning the general relationship contained in the training dataset.
How do we detect Overfitting:
The only way to know if your model is overfitting is to test its performance on a dataset it has never seen before. As such, overfitting is something you know with the benefit of hindsight following testing a model on data it has never seen before.

For this usage, where the answer is much simpler than recognizing a cat, isn't overfitting a good thing?

No, because if your model is overfitting it will perform bad on the test set(in your case, it will perform very bad when you deploy it in a real world ACAS and start showing it data it hasnt seen before). see How do we detect Overfitting above.
If it turns out that your model performs very well when you show it data it hasn't seen before, then that means it didn't overfit (see What is overfitting above).

What would overfitting "look like" in this case and why would it be bad ?
  Your model will get very high accuracy on the training set and get very poor accuracy when you start showing it examples it hasn't seen before. So in short, you will get your hopes high, jump up and down in excitement thinking that your model is great only for it no get very poor results in a production ACAS system.

Let's say a model has 100% accuracy on training data, and 80% accuracy on data it has never seen before; let's say that 80% is a good result for this type of problem. Would you say the model is overfitted?

Bump on Akavall's comment.
I'd say by definition, the model is overfitted. However, if 80% is a good result for that problem, I don't see why that would be a bad model. Perhaps calculate additional metrics to see a more in-depth view of the model.

Overfitting is almost always bad and hurts generalization. You say

what we want from the NN is to say "take a slight left turn" or "turn
  right hard" if another ship comes slightly close on the right or
  rapidly close on the left, respectively.

But what would you say if the NN learns to "take a slight left turn" only if the coming ship is small (because accidentally that's what the training set includes)? Or it learns to "turn right hard" only on a certain altitude and gives arbitrary answer when the altitude is different?
In practice, overfitting means learning the noise, i.e. the patterns that are not there. I can hardly imagine a good example, when it's what you really need.
To answer you question: it's quite possible that for ACAS task a much smaller and simpler model would work fine, not necessarily deep and even not necessarily neural network. But it must be reasonable and learning the white noise is not what you call reasonable.

No. When a system where input and output is well known ie. the state space is fully known and defined using say physics (PDEs) then overfitting is desirable as there is no need to generalize. An ML model has low inference time compared to solving the PDEs or lookup table is of multiple terabytes.

With such complete training data, is the result "overfitting" or just "fitting" though? I would say with such training data it is very hard to overfit, but overfitting could still be bad. You could get still get non-generalising behaviour with poor quality results between points at any density of training data, at least theoretically.

Nope. There is no need to generalize here. You have the complete state space.

If you have the complete state space, then arguably you are not overfitting. You are fitting to the data. So it is just semantics to say "overfitting is desirable". It is like defining a speed limit to be infinite by law and saying "speeding is desirable". IMO meaningless word play

@NeilSlater in terms of machine learning it is overfitting and a very useful term to use here. As it will direct one to not be using regularization, dropout, validation test etc. It is neither meaningless nor wordplay. This is called "useful overfitting". I suggest you be cautious while forming opinions at high speed giving little food for thought.

OK, so if it is overfitting, how does it manifest, exactly? Typically you will see validation error rise whilst training error falls. But that cannot happen when your training data is the entire function domain. How do you know your training has overfit, in order to say that you have "useful overfitting"?

I am not saying that having a lot of data, therefore not needing to regularise, is a bad thing, or that such scenarios don't happen. I am questioning the purpose of calling that "overfitting". Instead it appears to be training with enough data that overfitting is no longer a concern. It's not that overfitting is happening and somehow good now. It's that overfitting is not happening.


text:
Is iLQG a good algorithm for model-based planning with simple environments?
In their work Continuous Deep Q-Learning with Model-based Acceleration, the author demonstrate great results of applying Imagination Rollouts for model-based acceleration of learning. They test their algorithm on manipulation tasks in a Mujoco simulation.
I wonder whether similar accelaration would be possible in classic environments like Pendulum-v0.


text:
Can one use a trained recurrent neural network to find the most probable sequence of a set?
Let's say I train an RNN on the sequence of characters in War and Peace. After doing so is there a way I can take an arbitrary set of letters, e.g. HNTASK, and have it (ideally) tell me that the most probable sequence of that set is THANKS?
Also the algorithm must use ONLY the characters in that set; i.e. I don't want it to guess that U comes after H, even if U appeared in the training examples. After each character it can only pick from remaining ones. I would assume one would somehow disable the illegal output neurons to do this.
(I know there are far simpler algorithms for transforming jumbled-up letters to English words. This is just a toy example for an important problem.)


text:
Recommendations on which architecture to use to guess appointment
I'm currently developping an application which allows psychologists to manage their schedule and budget. As a proof of concept, I would like to create an intelligent appointment service. There can be 3 cases:

I know the client, I need to guess the day and time for his next appointment
I know the day, I need to guess which client and at what time
I know nothing, I need to guess which client, which day and what time

I'm currently in the process of learning deep learning algorithms just to get a bit of theory, but it's a little bit overwhelming.
There are features I know I can extract from the appointments:

Day preference in the week (always on monday, say)
Reccurence (every two weeks or such)
Nb of days since last appointment
Whether the client was present or not to his last appointment
etc..

I know there are things like "features extraction" that you can train a neural network to find the features itself, but all examples refers to image recognition or speech analysis.
I want the algorithm to train on the existing and future appointments (stored in a MongoDB). I would also like that the algorithm trains live, that is if it proposes an appointment to the user and the user takes it, it should train positively. On the other hand, if the user navigates or change any parameter, the algorithm should adjust its weights accordingly.
I also know I should start by extracting data from the DB that will be transformed in a vector or matrix, then the algorithm is supposed to train on that data.
Is this correct? How can I start and what kind of architecture do I need?


text:
Can Image Recognition used to find height of a person whole, torso, legs etc
Image recognition can be used to classify images. But I wanted to find few parameters like height of person, his legs, his hand etc. Will CNN helpful for this type of output ?

You can guess, but not really unless you have depth sensing data because your neural network will perceive things differently based on the camera angle.

@AidenGrossman If every images are taken from constant distance. Like.. If the distance from the person and camera is constant in all images. Will that work ?

it will probably work, but it still would not be as accurate as a depth sensing camera.


text:
Detecting symmetry in small images with RNN
My network works on 32x32 normalized (translationally) but noisy images. Its task it to determine whether image has simple symmetry (horizontal/vertical). It needs to be reasonably robust to rotation (up to 20 degrees).
I approached this task with a simple perceptron-like net with 2 hidden layers. It performs reasonably well (on limited amount of data that I have) but I can't shake off the feeling that this design is absolutely the worst for what i need.

It is hard to judge generalization capacity of the net (overfits
really easily)
It performs alot worse than a simple deterministic
program that i wrote for the same task

Symmetry is such a simple concept but my neural network (being feed forward type) can't represent it efficiently. What I have in mind is a kind of RNN that decides what axis to fold the image along and then judging on how well folded parts of image match. Are there papers on something like that?


text:
Is there a technical name for image classification on amount instead of class?
Is there a technical term for an image classifier that classifies on a single class but is classifying on an amount like how full a glass of water is rather than different classes?

Do you mean class probability distribution?

Training a system to predict real numbers instead of classes is called regression. If you had a training data where the inputs were images of water glasses and the targets were the amount of water in each glass, then this would be regression task from images of water glasses to the amount of water in each glass. You could call it image regression in the same way you would say image classification, but beyond that, I don't think there's a special term for regression where the inputs are images.

Ok, thanks. I've seen it called multi label before but that just doesn't sound right. The problem with calling it regression is it sounds like its using the old style linear method of image classification eg with bag of words, SIFT and SURF etc instead of using a convolutional network. I'm using a convolutional network with a euclidean loss instead of softmax to get a single value.

@ForthTemple Regression, classification, and multi-label classification refer to supervised learning problems--predicting real numbers, classes, and binary vectors, respectively, from annotated examples. Linear models and convolutional nets are two types of models that could be used to tackle any of these problems.Yes, you're right, often you can convert a classification model to a regression model by just changing the loss and the output transfer.


text:
Non-Convex Loss Function in Deep Learning Is a Big Deal?
I want to use deep learning to estimate the value of a function based on some data. However, the loss function would be neither convex nor concave. Can I know if it is a big deal in deep learning? Is training a deep network, when loss function is convex, the same as optimizing a convex problem or not? I would be thankful if any paper has addressed this issue.

Optimization
In optimization, the loss function (sometimes called the error function) is a function that aggregates the disparity between actual and ideal behavioral states in multiple dimensions and over a sequence of input cases.  In re-entrant (reinforced) learning, a feedback scalar or vector acts as a corrective signal that can replace or further aggregate with the loss function and additionally impact the training back-propagation.
Convergence
In any of these architectures, including systems without NN components but attempt to adapt by converging on an optimal static or moving target behavior, one generality can be made.  As the goal state is approached, the probability of successful convergence increases if the size of each incremental estimation decreases.  The estimation is nothing more than an informed guess.
Decreasing the learning rate as the detected convergence value improves is one strategy being used experimentally if not in production, but that strategy has drawbacks when used alone.  Involving the loss function in slowing down as the destination approaches is a best practice.
Biology Analogy
A biological system of a similar nature is the human subjective experience of pain.  As the pain level goes down, the human brain cares less about the pain, therefore the steps taken to reduce it decrease and eventually vanish.  Evolution has proven such to be advantageous for the same reason.
The Mathematics Involved
Maximizing the probability of an unknown function to be learned adequately to perform well is done in NNs by convergence.  The term gradient descent is often used to describe the iterative process intended to converge on some ideal characterized by labeled data, a concept built into the network, or some fitness signal.  The likelihood of converging on at least a local minima (which may or may not be the global minima) is much higher if the slope decreases as the minima is approached in successive approximation scenarios.  This is when d2E / dt2 is positive.
The geometric idea of convexity is correlated to the calculus concept of the second derivative of a line or surface with respect to time or some other measure of forward progress.  In successive approximation, the independent variable that measures forward progress could be time, computing cycles, the index of the training sample, iteration number, or some aggregation of these.  The second derivative is the rate of the rate of change.
Convergence is more likely if the rate of change decreases as the disparity between what is perceived as optimal behavior and what is the actual current behavior.  In other terms, the relationship between risk in making the next adjustment to circuit (NN) behavior should approach zero as proximity to the optimal behavior approaches zero.  (If one senses they have worked there way to close proximity of their desired state, it makes no sense to make wild guesses.)
An Easy to Visualize Analogy
If you drop a rubber ball into a rigid cone, it will take time to reach thermodynamic rest, at the bottom.  A lossless ball (considered impossible) will bounce forever.  A paraboloid (parabolic in two dimensions like a solar reflector) will produce faster convergence with the same rubber ball because the ball drops in energy (the sum of kinetic and potential energy) with each bounce.  The trajectory does not overshoot the bottom nearly as much or as frequently.  This analogy is not perfect, but it provides a visual image without a diagram.
If you aggregate your disparity between your target trained behavior and the current in-training behavior in a way where the second derivative is negative (concave loss function with respect to distance) on either side of the targeted ideal, convergence is much less likely.  In the analogy, the rubber ball is likely to bounce out of the flared cone altogether.  A lossless ball will always bounce out eventually.
A more provincial analogy is that it would be like trying to catch a baseball with the back of a baseball glove.
Concave, Convex, or Zero Second Derivative
Whether continuous or discrete, convex functions converge much more frequently and usually with less time and computing resource than concave ones.  A second derivative of zero is in the middle.  The word linear is actually incorrect for this zero acceleration case.  The correct term is first degree polynomial.
Sum of squares over the dimensions of the domain (inputs) and over the sequence of input cases will perform well in many cases.  If you were to sum the square roots of the absolute value of error instead, your NN will rarely converge at all.
Executive Summary
The following three things are more likely to be favorable if you find a way to aggregate your disparity between ideal and actual current behaviors in a way where the second derivative is greater than zero.

Reliability of eventual convergence
Speed of convergence
Response time in the case of re-entrant (reinforced) learning
Savings of computing cycles
Reduction in the complexity of introspection
Conservation of computational memory (RAM or SDD)
Conservation of space needed for persistance and archiving
Reduction of project cost to the business


text:
Writing a knowledge base (KB) in propositional logic and converting the KB into conjunctive normal form
If you walk your dog, he'll be happy. If you don't walk him, he'll chew up your furniture. If he's happy or if he chews your furniture, he'll mess up your apartment. If he messes up your apartment, you'll be annoyed.
Does your dog mess up your apartment?
Are you annoyed at him?

Write the knowledge base given above in propositional logic.
Convert the knowledge base into conjunctive normal form.
Use resolution to prove by contradiction that your dog made a mess. Connect the two clauses to a new clause that the can be collapsed into (see the example figure).

Example figure:


text:
To what extent can artificially intelligent agents reliably predict trends in financial markets?
I've gotten curious about this topic and am wondering what the stack exchange community has to say about it. Also, does anyone know of any professors/researchers who have published papers pertaining to this?

Welcome to AI!  Very good question. It is estimated that 75% of US market activity is conducted by automated systems, and I don't expect that number will decline.

This is a highly relevant question as market trends have become more emphasized over the fundamentals of individual companies, and algorithmic trading has proven to be quite effective, particularly in areas such as high-frequency micro-trading.
This 2013 Forbes article estimated nearly 80% of stock trading volume in the U.S. is conducted by automated trading systems.  More recently, Bloomberg published an article on the subject: The U.S. Stock Market Belongs to Bots.
The massive adoption of algorithmic trading in a fairly short span is a pretty good indicator that these systems are effective.  However,

My feeling with any predictive system is that it works until it doesn't

Imperfect and Incomplete information are persistent in real-world scenarios.  The implication is that there are always unknown factors that can diminish quality of analysis, and even lead to disastrous outcomes.
No matter how complex an algorithm becomes, reality is more complex, (at least for the foreseeable, pre-singularity future;)
Adding to that, systems in general tend to be imperfect, and when engaged in massively repetitive functions, small errors can grow exponentially and produce catastrophic effects.
"Flash Crashes" are a recent phenomena, and a result of algorithmic, high-frequency, black-box trading.

A couple of thoughts:

Humans can't reliably predict trends in the stock market, so expecting AI's to do so is probably unreasonable.
The above would be more true if it were proven that the movement of stock prices is really a random walk, but my understanding is that the current thinking is that stock movements aren't completely random... but just really close to random.
If there are some trends there that represent a useful signal, and if somebody has found that, they're very unlikely to share that information, as the market would then immediately price that information in and they would lose their edge.

There is quite some research done by Hans-Georg Zimmermann, who has programmed Neural Networks for Siemens since some 20 years in order to predict Stock markets. He wrote some books on it, too, though I don't know if they are any good in English.
This article gets to the point a bit faster than the video, I hope it helps.
edit: I think this interview gives a good short introduction to his work.


text:
Any software to guess idea flow (basic ideas/statements and their derivations) throughout text?
Is there any existing software which analyzes idea flow in the text (or between different texts, e.g scientific articles) and for example visualizes it with some graph?


text:
Crossing complex and non uniform genomes?
I've been tinkering with an artificial life simulator, critterding for many years and lately ive been branching the project and adding fitness functions.
Im still quiet new to genetic algorithms and currently critters in the simulation have very complex and different sized dna files which i want to be able to cross, currently they can only reproduce asexually and evolve purely through mutation.
For example, thier genome consists of:
Box part dimensions
Joint locations and angle constraints which connect those boxes
And a list of neurons, thier properties and synaptic connections
The number of boxes and thier joints can change by mutation as well as the number of neurons and synaptic connections and so im having a hard time trying to think up a crossover approach which can handle these variables.
So my question is, can anyone point me in the right direction for research material or give me insight into handling such dna structures for crossing?


text:
Is accuracy of a machine learning algorithm independent of the features?
I’ve been experimenting on several datasets and found something very strange while implementing ML.
I’ll Explain after the code…
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()

# 4 features in np array - 150 rows

case = 1        # change cases to see variation

if case == 1:   # first feature deleted
    iris.data = np.delete(iris.data,0, 1)

if case == 2:   # first 2 features deleted
    iris.data = np.delete(iris.data,0, 1)
    iris.data = np.delete(iris.data,0, 1)

if case == 3:   # first 3 features deleted (1 feature left)
    iris.data = np.delete(iris.data,0, 1)
    iris.data = np.delete(iris.data,0, 1)
    iris.data = np.delete(iris.data,0, 1)

if case == 4:   # only second feature deleted from np array
    iris.data = np.delete(iris.data,1, 1)

if case == 5:   # only third feature deleted from np array
    iris.data = np.delete(iris.data,2, 1)

if case == 6:   # only last feature deleted from np array
    iris.data = np.delete(iris.data,3, 1)

# print iris.data
# exit()

from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
pred = gnb.fit(iris.data, iris.target).predict(iris.data)
# pred = gnb.fit(iris.data, iris.target).predict(test_data)

from sklearn.metrics import accuracy_score
print accuracy_score(iris.target, pred)

I’m using the basic fisher iris dataset from sklearn, it has 150 rows and 4 columns (features).
Using training data as test data.
So i tried to remove a few features and see if accuracy changed.
And I thought it would.
But till case 1, 2, and 3, I removed 1, 2 and 3 features respectively and there was no change in the accuracy. It stayed 96%.
Then on running cases 4,5 and 6, The accuracy changed. Why?
On comparing case 2 and 4,
Both have second feature removed from the dataset, so clearly, removing second feature is responsible for change in accuracy (as seen in case 4)
So why does it not change in case 2?
Just because it had first feature removed too? to balance out the second? (If that were true, case 1 would have given different accuracy)
Why does accuracy not change in first 3 cases, but it does in the last 3 cases?
Is ML dependent on the order in which features are feeded to the algorithm?
What am I missing here?
Would be great if someone could clear this doubt.
Thanks!

Welcome to AI stack-exchange. Good question by the way :). I just wanted to point out to that "Using training data as test data." - is a recipe for overfitting. Which means that the accuracy you are seeing is not the real accuracy you can expect your model to get if you test on a dataset your model hasn't seen yet.With that said, I understand why you did that.... the iris is a small dataset :(


text:
Can a multi-camera system be used for localization, mapping, and obstacle detection in self-driving cars to within 10 cm of accuracy? Whither lidar?
I have a liberal arts background so I need help understanding this paper, particularly pages 26 to 30. The authors test a four-camera system for localization, mapping, and obstacle detection for self-driving cars. The paper seems to say the multi-camera system can map the environment to within an average of 7 cm (2.8 inches) of accuracy (with the largest error being 16 cm or 6.3) and detect obstacles to within 10 cm (3.9 inches) of accuracy. Am I getting this right?
Given that automotive lidar can detect objects to within 1.5 cm (0.6 inches) of accuracy, and given that for driving purposes the difference between 1.5 cm and 7 cm, 10 cm, or 16 cm seems quite small, can a multi-camera system be used instead of lidar in a self-driving car application? How do driving speeds affect things? What crucial elements of the problem space might I be overlooking or misunderstanding?

It seems that LIDAR presents a problem for resolving the car's environment at higher speed. While I'm not too familiar with the dynamics of LIDAR I do know that it's a physical system that relies on sending and receiving laser pulses to various points around the car by way of rotating mirrors. As speeds increase, it seems different arrangements of mirrors and light collectors might have to be used to maintain a high-resolution image. There's some evidence that Doppler LIDAR (developed in the 1990s) became less accurate with higher velocities. However, LIDAR is partly preferred over radar because of its higher accuracy even when tracking objects at high speeds - this is why LIDAR guns are increasingly being used by police instead of radar guns to track speeding vehicles. It seems natural that a set of high-resolution cameras paired with a well-trained neural network would not be subject to the same physical limitations as LIDAR.
I think that an important intuition to consider is that while LIDAR is used to generate clouds of data points whose shapes and patterns can be analyzed by autonomous car software, cameras can pick up non-topograhical features such as road lines, the content of roadsigns, and additional location context such as storefronts and intersection layouts. Considering that these cameras can use pattern recognition and stereoscopy to also generate a 3D topographic map of the environment, it seems plausible that Level 5 self driving cars would not require LIDAR.
Here's an interesting look at the problem.

Given that a self-driving car is trying to replicate the performance of a two-camera system (or one in a pinch), there is nothing in principal that mandates lidar for a self-driving car.  Lidar is a shortcut, substituting sensor sophistication for image-processing sophistication.  AFAIK Nvidia's own self-driving vehicle  doesn't have Lidar.  My personal opinion is that Level 5 self-driving vehicles won't be practical until they have the kind of image-processing sophistication that makes Lidar an unnecessary crutch.


text:
how to write a recurrent auto associative network?
I need to write a recurrent autoassociative network in python . I have read Explorations in Parallel Distributed Processing: A Handbook o f Models,Programs, and Exercises but I can't understand how are the activation updating cycles written. any information about this would be helpful. specially if i could find an algorithm for this .

https://datascience.stackexchange.com/ is a better place to ask questions about the implementation of ML algorithms


text:
Examples of "crossmodal" integration failures in artificial cognitive systems
I was wondering if anyone can think of any examples of integration of audio-visual inputs, or other modalities, failing or resulting in undesired outcomes in artificial cognitive systems?
I'm interested in any issues, or artifacts, that have arisen when different information about the same event have been integrated in such a system.
Published, or discussed in print online, or even a TED talk would be great sources if you know of any. Anecdotal evidence of such scenarios that you may have experienced are also of interest.
Thank you all for your time.


text:
Constraining the output value range of a CNN independent of the loss function
I'm having the following problem: `
I'm training a multi-output CNN and using the relative values of the outputs in my loss function. The net is learning well, but as the absolute values of the outputs are not regularized in anyway in the loss function, the values of the outputs keep rising. This causes a situation where the result I need (values of the outputs relative to each other) are quite right, but the huge absolute values produce underflow resulting NaN values at some point of the training. Is there some way to constrain these absolute values (perhaps elsewhere than the loss function?)
I'm using a custom loss function implementing a recovery angular error metric, so the loss function is somewhat complex. A weighed mean of the net outputs is fed to this function, so using both the net outputs and the weighed mean would lead to some quite problematic gradient derivation. Would it be maybe possible to constrain the value range of the net outputs in the net structure itself?

You can limit the absolute values of the outputs by "punishing" large values in the loss function. This is done by adding an extra term to the loss function.
For example, if your existing loss function is L(yhat, y) where yhat is the output and y the correct value, create a new loss function
L'(yhat, y) = L(yhat,y) + max(0, ||yhat||1 - k)
When the outputs are "small" the L1 norm of your output yhat is less than k and imposes no extra loss (keeping everything as before). However once the norm grows above k it starts to impose a loss that guides the training to reduce the absolute values of the outputs values.
You can also limit the values in the network itself by selecting a bounded activation function for the output, for example tanh or sigmoid. However, you need to pick an activation function that suits your problem.


text:
Image recognition service architecture
A question for developers of projects for pattern recognition. How best to organize the architecture of such a service?
At what stage do you conduct logic? (for example, for the recognition of a photo of a male blue jacket, a cascade of queries is performed: "recognizing men" -> "recognizing the jacket" -> "recognizing the color of the jacket.")
Does it make sense to implement all search options within a single neural network or is it better to create a set of individual neuronets that are confined to fairly simple tasks?

That is one of the good example for research. Personally, I prefer to segment out all the desired outputs at once. Then, check the success rate. If you cannot hit the success rate that you desire, you can go for more specific solutions for the specific problem that you face.
However, in general, the localization, segmentation, recognition are implemented in same network and are obtained all-at-once.

I would use a single network:
The essence of the question is whether or not doing all the classification work at once is more efficient than running individual classifiers for each stage.
The recent "You Only Look Once" algorithm ("YOLO") is based on the fact that the convolutional networks can reuse a lot of the interim calculations if you combine them into one. Because of this, they are able to perform real-time object detection on images across thousands of classes.
You can express your hierarchical classifier with YOLO (man, jacket and jacket colour classes). Depending on your needs, you might want to model the jacket colour as a scalar output of an approximate R,G,B value for the colour rather than having named classes for the colours.
This everything-at-once implementation gives you runtime efficiencies for the inference step and much faster training since the classes share common abstractions in the earlier layers of the net.
Details, the YOLO version 2 paper, and a cool demonstration video featuring James Bond are available here: https://pjreddie.com/darknet/yolo/
The paper itself, "YOLO9000", is available on Arxiv: https://arxiv.org/abs/1612.08242


text:
Reading a value of a real gauge
I have a simple gauge displaying analog values ranging from 0 to 4.
Here is an image of the gauge. Unfortunately there is no way to get a analog or digital signal for the value.
How do I read the value of the gauge?
My idea is to make an image every 5 minutes and get the value by analyzing it. I am thinking of manually generating reference images with the black needle in different positions and then compare it to the real image.
Since all the processing should be done on a raspberry pi without internet connectivity, a good approach would be a preconfigured docker image for image comparison which helps doing the image comparison locally, maybe supported by a python or php script.
How to proceed?

Why the heck a -1 voting? What's wrong with this question?

Is this too simple? Please give me a hint, where this has already been solved...

Downvotes without explanation (and often without obvious reason) are common here, don't worry about it. It might have been because your question is not a real AI question, but can rather be solved with a simple image processing algorithm. Nevertheless, Computer Vision is considered an important part of AI development right now, so I think it can be argued that the question is still on topic. +1 from my side for the interesting challenge.

This is a simple digital image processing task. I am proposing a quite efficient solution without any error correction mechanism, so this is not a production quality approach. But as a first proof of concept it should do the trick.
The easiest approach would be splitting the image in two channels - one for the color red and one for the color black. You can neglect the rest outside a certain threshold. If the lighting is good, this should also deal with the background.
Step 1: Crop away everything outside the gauge to simplify your life. The easiest way to do this is just putting the camera close enough that it only captures the gauge. That way you don't have to implement it in your algorithm.
Step 2: The center of your image will be the red dot in the middle of the gauge. You can easily identify it with a filter looking for the largest concentration of red in the red channel of your image. Calculate the center and remember the coordinates.
Step 3: Do the same for the largest concentration of black in the black channel. This will be the thick end part of the black needle. Calculate the center as well and remember the coordinates.
Step 4: Calculate the vector between those two coordinates. The angle of the vector will tell you the angle of the needle (take care of the direction of the vector). Once you have the angle of the needle, you can easily derive the number it is pointing to.
There are obviously much more elegant approaches to solve this problem, but this quick and dirty algorithm should do the trick without a lot of hassle. You need to make sure that the camera is positioned in the right angle, because we haven't implemented any error corrections in our algorithm. You also need to make sure the lighting is sufficient and that there aren't any other significant influences on the image quality. As long as the orientation is stable and the image quality high, this should enable you to read the gauge with good precision.

I have made something similar that could run on a Pi. Python and the OpenCV library work very well for this if the camera position, light and gauge are similar in all the images.


text:
How can an AI make tactical manoeuvres?
I'm working on a multi-player game that involves a board/map where there are walls, cover or open ground. The players then take turns moving units around and undertaking discrete actions, like move, fire etc.
I've been exploring adding an AI for single-player games, or to enhance multi-player games. I've looked at:

Behaviour Trees
Utility-based decisions
GOAP

The problem I see with all of these is that in order for the AI to use specific multi-unit tactics, like a pincer attack, or leap-frogging units; that behaviour needs to be explicitly added separate to the above.
So, how can a Behaviour Tree tell an AI how to identify it should use a Flanking manoeuvre, i.e. move a unit around to hit from the side? How does the AI identify that it's a good plan, that is action across multiple "moves"? How can the AI identify where to move the individual units in order to pull this off (how does it identify the flank)?

Reinforcement learning is the best fit for problems like these. To get started explore how DeepMind solved Atari games. The key is self play. RL works through trial and error and eventually figures out the best strategy. You also need to tweak so that it does not play at God level making it impossible for users to win.


text:
Is it possible to restore scrambled/damaged text?
Given an ease with which a human can read a text scrambled in a special way, like the following passage popular a while ago

Aoccdrnig to a rscheearch at Cmabrigde Uinervtisy, it deosn't mttaer
  in waht oredr the ltteers in a wrod are, the olny iprmoatnt tihng is
  taht the frist and lsat ltteers be at the rghit pclae. The rset can be
  a toatl mses and you can sitll raed it wouthit porbelm. Tihs is
  bcuseae the huamn mnid deos not raed ervey lteter by istlef, but the
  wrod as a wlohe.

could you train a computer to restore the original? Are there any studies/known instruments that can achieve this?
I am talking about mildly scrambled/damaged text, like the above, not a totally random permutations or random omission of letters.

You can rephrase your question as a statistical problem, where you for each word or n-gram try to predict the most likely correctly spelled version of each word or n-gram based on your knowledge of the distributions of these across a corpus of text in the target language.
This is how spell-checkers work.
Peter Norvig (who wrote Artificial Intelligence: A Moderne Approach with Stuart Russell) has an article on the this with a short, easy-to-read code example and a description of the statistics behind it on his web page: How to write a Spelling Corrector.


text:
Making behavior tree execute action for specific time?
Say I need to make an action such as "Walk" perform for 2 seconds using a behavior tree which has access to a timer.
The timer can do the following:
start, time (get value of timer), and reset.
If the behavior tree should return Success every time "Walk" is completed, unless the timer reset or "Walk" is still executing, how could such a thing be built?


text:
Has there ever been a model (neuro-physical) proposed for the human unconscious brain?
Has there ever been a model (neuro-physical) proposed for the human unconscious brain?

I tried reading on unconscious mind but couldn't find anything which answers the question.

Is there any literature related to it?

Welcome to AI.  This is a good question!  One of Hubert Dreyfus's critiques is "...that human intelligence and expertise depend primarily on unconscious instincts rather than conscious symbolic manipulation, and that these unconscious skills could never be captured in formal rules."

@DukeZhou Thank you for your response :)
Though it didn't help much, but, "still something is better than nothing".

It may be that AI is not sufficiently advanced to be regarded as having consciousness, or even minds, and so unconscious mechanisms aren't yet relevant, except from a philosophical perspective.

please update your question for further clarification

The Unconscious in psychology is related to many aspects of behavior, but many levels of this exist, including low levels (simple tasks) like walking, eating, breathing etc.  This has been investigated in animal world, for example muscular memory, the insect brain model, and Nonlinear System Control Using Neural Networks . Many of these are related to body control.
See also: nested hierarchies of circular emotional control and cognitive regulation for “bottom-up” influences and “top-down” regulations

Can you provide a note on the distinction between autonomic processes and subconscious psychological processes?  (The links you provide are good, particularly Nonlinear System Control Using Neural
Networks but I feel like this answer would benefit from a little more granularity.)  PS-Welcome to AI!

[link] (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5573739/figure/F1/)

Thank you for your answer. Though it's not satisfactory, still gives something to ponder upon.


text:
What qualifies a Voice Assistant to be an AI?
If some claim they are doing Artificial Intelligence by providing a Voice Assistant, what shall we expect from this Voice Assistant for the claim of doing "Artificial Intelligence" to be correct?
Examples of potential qualifications:

is replying "Hello" to "Hello" enough?
is repeating any word you said enough?
is identifying you by your voice enough?
shall it support corrections? "what is my favorite color?"/"red!"/"no, it's blue. What is my favorite color?"/"blue!"
shall it support emotions? "I would offer you better service if you could say thank you sometimes"
shall it support self-awareness? "Dear master, may I ask you a question about me?"
etc.

Usually, this sort of encoded 1to1 response is not considered to be AI or ML. This is because a chatbot that simply responds to a designated string with a response string is hard programmed(for the most part). A lot of companies/individuals have tried to package this as true AI but it is not.
One of the simpler examples of an AI chatbot system is a model that does some sort of tree-search or similar for the input. This is more often than not, extremely naive but would be an example of a true AI system.
So to more concisely answer your question, the categorization as an AI chatbot would have less to do with the responses, and more to do with how the model selects/comes up with those responses.


text:
Can CNN autoencoders be improved by treating the output layer as an inverted hidden layer?
I wish to write a bot that can use screen footage to play a game, specifically for the game 'Nidhogg'.
To that end I have determined that a CNN should do the feature detection and a feedforward neural network should determine the action to take.
For this question I wish to focus on the CNN.
My idea was to first train the CNN as an autoencoder to aid in unsupervised pattern recognition and to add hidden layers after every epoch, but I am unsure whether this would actually be faster or lead to higher accuracy (as opposed to immediately training all hidden layers at once).
The reason I am unsure is because I imagined the following scenario:
Input > Hidden1 > Output

If the output layer needs to approximate the input layer is it not wasteful to let it have its own weights backpropagated when it actually tries to determine the 'inverse' function of the hidden layer? Is it possible to 'directly' determine an inverse function for a layer even if consists of multiple filters?
If so, say I've trained my first hidden layer so that the error is minimal and use it as an input layer whilst I add another hidden layer; can I repeat my strategy?
Input > Hidden1 > Output
    Input(Hidden1) > Hidden2 > Output

It seems like what you need is reinforcement learning method rather than AE / unsupervised. Method has to be like
Input -> CNN Feature Extractor (encode side of AE, i.e. VGG) -> Classifier (i.e. DNN) -> Choose one of the actions -> Observe change in the game and check if it was a wrong (like character is dying) or good (character is moving forward) and give a rating to action (feedback of decision).
After a while, AI will learn how to jump over obstacles, avoid stuff etc.


text:
Should I be using a validation curve accuracy score in lieu of error bars for a model fit to time series data?
Normally when doing a fit to some time series data (e.g., a polynomial fit), functions will return an associated error with each fitted point. I'm now trying out scikit-learn's support vector regression (SVR) fitting instead, which doesn't have any such return. There is a handy function in scikit-learn called validation_score that can tell me the accuracy score of various fits, from which I select the best one. So maybe that's good enough? But as a scientist, I'm wondering if this will get slapped down in peer review of a publication.
What's the right way to propagate the errors of my time series data through the SVR fit?


text:
Decision tree doesn't quite work, is there a better alternative?
I have a problem that I have been trying to use decision trees to solve. There is a data set of pricing information for products sold by a company. The goal is to infer the pricing algorithm for each product based on the product's name, type, and characteristics. However, the data is incomplete and may contain a few inaccuracies due to manual data entry.  Products can be priced using several possible algorithms:

Price is a fixed dollar amount (widget costs $20)
Price is a percentage of MSRP (widget costs X% of MSRP, note X could vary by product classes)
Price is based on a cost per piece (package of widgets costs $2 per piece)

Using decision trees, I have been able to identify the products priced using algorithm #1, but have struggled to make progress on algorithm #2 and #3. Since price is a continuous variable, the leaf nodes always represent the average of the target variable. But this doesn't seem to work for #2 and #3, since these would be a function of other variables, not the dependent variable.
Is there a clever way to implement this using decisions trees? Any recommended alternate techniques that could identify the pricing algorithms used? Note, I am not interested in predictions, but rather explain the pricing rules/algorithm that fit the existing data.
I am using SAS Enterprise Miner, but may have access to other tools as well.

Are you actually sure that you have identified 1) seeing as products could cost $20 even if priced according to mechanisms 2/3. Seeing this I doubt how you could find this out definitively without knowing X and widget cost for each product. I think this is a lack of data problem not one of algorithm choice/application.