text:
How would I implement this New Type of NN
CIO NN
CIO NN stands for Controller Input Output Nerual Network
note due to a typo the "nearon" means "neron"
For this we have to redefine the Nearon

2 Inputs
2 Outputs
4 Weights (each input and output have their own weights)
Internal Memory Cell (any byte or bit or block size with variable size)
Activation Function (Defines what weights and what inputs activate this Nearon)
Memory Storage Function (Defines what and when this cell should store said memory or memory stream)
Memory Transpose Function (Once activated any stored memory that the activation function can trigger will be played/pushed into the Nerual Network)
Forget Function (Defines when and/or how and/or why these memories can be destroyed/removed based on Activation function with Memory states and any input stateses itself)

How would I implement this in the form of Code?
please take note of the spec. (this is non profit/GNU v3)
This would look something like these:

These would be arranges like this:

Which we can build it into this:

it can be trained like this:

do normal NN training from the inputs to the input outputs like a hidden layer NN

then trained to be controlled like this:

then set the known NN dataset (inputs) to be corrected to actual or correct values via the CI (Controller Input) which will be outputed on the "Input + Controller Input" Output

by training like this:

you have a normal NN with hidden layers which can be trainned (this can be done with CNNs) with backpropergation, and a cost function (use least amount of nerons) etc
now you can allow the CIO NN to retrain / teach itself with supervised or unsupervised learning.
you can combine the "Input Output" and the "Input + Controller Input" Output with another NN which can then connect with this NN in a similiar way that a Neron connects to a Neron


text:
What model to use to get a robust model to predict next 3 days of sales even for products that have just sold once ever?

PROJECT: I am working on an e-commerce site where digital products can run out so there is need to reorder them 72h before they run out (reordering them sooner is not a problem but having notification a bit later so if the product would sell better that would be a problem because we cannot reorder products in time).
GOAL: is to know if products run out at least 72h earlier.
DATA COLUMNS: sales datetime, product id, current number of products, price of product, what currency it was purchased in, other data like profit currency was used for the purchase…
SIZE: Before grouping I have a few millions of rows after grouping hundreds of thousands so it is a lot of data point but DASK can handle them.
GRUPPING COLUMNS: I have grouped the data by PURCAHSEDATE & ID so each day has the product that were sold with all its feature. Features have been aggregated mostly buy summing (profit, expenses) and mean (percentage features like margin%)
HOW FAR I HAVE GONE WITH THE PROECJT: I have looked up a couple of Kaggle projects online that were focused on use https://www.kaggle.com/tejasrinivas/simple-xgb-starter
PROBLEMS: A.) Some product has been sold in the past but they are selling out in 1-2 days so it is hard to put trendline on it. B.) Some item just has 1-2 days of data because it just started to sell a few days ago. C.) I also have data of products that have been sold a lot for a mid or long run (hundreds of days thousands of times). So I could do time series modelling on the whole of the sales but for each individual item I don't always have data on it
CURRENT RESULTS: I have used XGBOSOT Regression like It predicts well number of products sales after the days is over with all the features, but that is not the goal  - https://www.kaggle.com/tejasrinivas/simple-xgb-starter
PROJECT RECOMMEND:I am trying to use the following pick ideas from the following competitions: https://www.kaggle.com/c/demand-forecasting-kernels-only/notebooks?competitionId=9999&sortBy=voteCount  ,  https://www.kaggle.com/c/competitive-data-science-predict-future-sales/code
GOAL: simple and easy solution, not LSTM or something complicated but something quick and easy (like xgboost regression so if I have more data I can use rapids.ai to GPU teach it) to implement because as I said it is not a problem if it is missing on the time frame on the positive side and the item gets reordered 96h early and not 72h early. I am guessing that somehow, I should shift the dates but as I said in many case items have not enough dates to shift their sales date.

If you have sold only once or very few items you will need some prior input (domain knowledge). One term for search is intermittent time series. Here is a stored search.
When you have many time series, related, and interest in both totals and single series, that is called hierarchical forecasting.  One expert is here (the author of that blog was the founder of sister site Cross Validated).
With time series forecasting it is often difficult to beat simple methods,  see https://stats.stackexchange.com/questions/135061/best-method-for-short-time-series/135146#135146

source: Stack Exchange

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

sort: votes


text:
What are the main advantages of using declarative programming languages for building AI?
What specific advantages of declarative languages make them more applicable to AI than imperative languages?
What can declarative languages do easily that other languages styles find difficult for this kind of problem?

The advantage of a declarative language like Prolog is that it can be used to express facts and inference rules separately from control flow.
This allows the developer to focus on the data and inference rules (the knowledge model), and allows the developer to extend the knowledge model more easily.
I should add that in practice, this dichotomy between facts/rules on the one hand, and control flow on the other, is not strict. A knowledge engineer who writes a code base in Prolog does sometimes have to consider control flow. The "!" operator is used so that the developer can influence the evaluation of the rules.

There's no objective reason to state that declarative languages are better suited for AI development. However, there's indeed a bias towards them in practice. Although most functional languages are impure (that is, they allow side effects), and such can't count as "declarative", a few languages are purely functional (that is, they don't allow side effects), most prominently Haskell. Purity is key here. In Haskell, even I/O is pure.
The key difference between imperative languages and (purely) functional languages is in the way they describe the program. An imperative program describes how to do stuff, that is, algorithms. It specifies the specific instructions that the machine must carry on in order to perform the computation. OTOH, purely functional languages describe what is to be computed, that is, the relationship between the input and the output. In mathematics, "function" is just a fancy name for a relationship between an input and an output.
Again, in the mathematical sense, the only variability is that of the function's arguments. That is, the function's output depends solely on its input (arguments). This is known as referential transparency. Referential transparency states that:
$$
\forall f \in \varphi, \forall x \in \delta_f, fx = fx
$$
Where $\varphi$ is the set of all functions, and $\delta_f$ is $f$'s domain. For the typical imperative language's definition of "function", the above doesn't hold. For instance, C's getchar() does not always return the same value.
Let's say we want to calculate the set of the ten least prime numbers whose least significant digit is $3$. First, in mathematical notation:
$$
\mathbb{S} = \mathbb{G}_{10} = \{ x \mid x \in \{ p \mid p \in \mathbb{N} \setminus \{0, 1 \} \text{ and } (\forall q \in \mathbb{N} \setminus \{0, 1, p \}, p \text{ mod } q = 0) \},  x \text{ mod } 10 = 3 \}
$$
Where G(n, s) is the set of the lesser nth elements from s. In mathematics, you don't worry about how is the set $\mathbb{S}$ supposed to be computed, but rather about $\mathbb{S}$'s definition itself.
Now, in Python (in imperative style):
def is_prime(n):
  for x in range(2, n):
    if n % x == 0:
      return False

  return True

def foo():
  s = set()
  n = 2
  while len(s) < 10:
    if is_prime(n) and n % 10 == 3:
       s.append(n)

  return set(s)

In Python, we care about (and are responsible for) the algorithm being used to compute the set. We specify, pretty much in recipe-style, how to build the set from scratch. If there's an algorithm that may be better suited for checking whether a number is prime or odd, but we don't use it, it's our fault, not Python's.
Finally, Haskell steps in:
import qualified Data.Set as Set

isPrime :: Integer -> Bool
isPrime n = ( == 1 ) . length . filter ( == 0 ) . map ( n `mod` ) $ [ 2 .. n ]

s = Set.fromList . take 10 . filter ( ( == 3 ) . ( `mod` 10 ) ) . filter isPrime $ [1..]

Haskell's version is a lot more like the mathematical model than Python is. We define the isPrime function in terms of the constraints that a prime number must obey, not by describing a step-by-step algorithm to do such a check. Moreover, s (the set we have been defining so far) is defined in terms of the constraints its members must obey, rather than in terms of an algorithm to compute s itself. The compiler, more often than not The Glorious Glasgow Haskell Compilation System (a.k.a GHC), is the one responsible for generating an algorithm. GHC's optimizer is known to be one of the strongest in the world, not because its the best compiler of 'em all, but because Haskell's nature allows for this.
Haskell (and other functional languages), in summary, have several features that make it look, taste, and behave like pure math:

Referential transparency and purity.
Haskell is lazy.
A very strong type system, with such exotic (but very useful!) stuff as recursive (and algebraic) data types.

So, the bottom line is that AI researchers often prefer functional languages over imperative languages (or, more assertively, pure over impure languages), because they are attempting to define artificial intelligence itself, by means of functions (relationship between an input and an output). At the end, we do this because we have no real algorithm for human-level intelligence to raise from a handful of transistors. Also, there's been a historical bias towards these kind of languages, starting with John McCarthy, Lisp's creator and a pioneer in early AI research.

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

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


text:
What exactly are the differences between semantic and lexical-semantic networks?
What exactly are the differences between semantic and lexical-semantic networks?

"semantic network" is way of representing "semantic" relations in form of a "graph" . where as "lexical semantic network" is a type of semantic network which represents the relations between words , sub-words or some-other linguistic related terms. so in other words , lexical semantic networks are a type of semantic networks dealing with language relationships.

would you mind if I add links in this answer to Semantic network and Lexical semantics?  (Reviewing your concise synopsis of the concepts, there doesn't seem to be any conflict with the wikis, but wanted to run it by you for approval.)

According to Wikipedia  and
Semantic Networks
 ,By John F. Sowa
This is an updated version of an article in the Encyclopedia of Artificial Intelligence, Wiley, 1987, second edition, 1992.

A semantic network is used when one has knowledge that is best
  understood as a set of concepts that are related to one another.

From Wikipedia:

Most semantic networks are cognitively based. They also consist of arcs and nodes which can be organized into a taxonomic hierarchy. Semantic networks contributed ideas of spreading activation, inheritance, and nodes as proto-objects.

An example of semantic network is WordNet. It groups English words into synsets. Some semantic relations between these synsets are meronymy, hyponymy, etc.
On the other hand, Lexical semantic:

...explores whether the meaning of a lexical unit is established by looking at its neighborhood in the semantic net (words it occurs with in natural sentences), or whether the meaning is already locally contained in the lexical unit.

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


text:
How to detect the empty parking spots?
I have some images of the empty parking as shown below.

I 'd like to use deep learning to extract the parking spots. But in the beginning,am confused whether there are several ways to do the following;

Treat each parking spot as an object and use object detection to find
the parking space.
Treat the parking spot as a few key points, instead of finding the
spot, try to find the coordinates of key points on the parking line.

Any ideas on how would I work on these two methods

Object detection is a regression of the bounding box (rectangle) around the object. In this way, the two ways you suggest are equivalent.
What I suggest you to look at is lane detection for self-driving cars - a well studied problem. It seems that this is a very relevant task (if not the same), so its solution should work for you as well.


text:
Answer Set Programming - Make a Fact INVALID
I have a question regarding Answer Set Programming on how to make an existing fact invalid, when there is already (also) a default statement present in the Knowledge Base.
For example, there are two persons seby and andy, one of them is able to drive at once. The scenario can be that seby can drive as seen in Line 3 but  let's say, after his license is cancelled he cannot drive anymore, hence we now have Lines 4 to 7 and meanwhile andy learnt driving, as seen in Line 7. Line 6 shows only one person can drive at a time, besides showing seby and andy are not the same.

1 person(seby).
2 person(andy).
3 drives(seby).
4 drives(seby) :- person(seby), not ab(d(drives(seby))), not -drives(seby).
5 ab(d(drives(seby))).
6 -drives(P) :- drives(P0), person(P), P0 != P.
7 drives(andy).

In the above program, Lines 3 and 4 contradict with each other, and the Clingo solver (which I use) obviously outputs UNSATISFIABLE.
Having said all these, deleting Line 3 and getting the problem solved is not what I'm epecting. The intention behind asking this question is to know whether it is possible now to make Line 3 somehow invalid to let Line 4 do its duty.
However, Line 4 can also be written as:

4 drives(P) :- person(P), not ab(d(drives(P))), not -drives(P).

Thanks a lot in advance.


text:
Goal oriented Action Planning with multiple Agents
I'm a little bit stuck:
I implemented an AI with GOAP (Goal oriented Action Planning, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf) for a simulation game. That works fine.
Now I want that the agents can cooperate (e.g. doing actions together). What is in this case the best AI-Design that the GoapActions keep loose couplet?
Should they plan together? (what is in this case the "worldstate"?)Or Should they share their plans?
Example
Agent1:
Worldstate Agent 1: isLonely= true
Goal Agent1: isLonely = false
Plan Agent1: AskAgent2ToTalk -> TalkToAgent2
Agent2
Worldstate Agent 2: hasWood = false
Goal hasWood = true
Plan Agent2: GetAxe -> ChopWood -> BringWoodToSupply
How I get this constellation?
Agent1 Plan: TalkToAgent2
Agent2 Plan: TalkToAgent1 -> GetAxe -> ChopWood -> BringWoodToSupply
Or if they are talking and one of the agents is interrupted (e.g. by an attacking enemy) the other agent must know that his TalktoAgent2 Action has ended.

what do you mean "How I get this constellation?" have you set up the environment and the actions?

yes, the environment and the actions are set up. (the simulation works with multiple agents but they are not cooperate at the moment)
The question is how should agent1 alter agent2's plan, that agent2 has TalkToAgent2 as current Action (if and only if Agent2 like to talk). and after that how agent1 knows that agen2 want to talk with agent1 (has TalkToAgen1 as current Action). I hope my explanation is clear now.

You shouldn't expect to be able to program explicit some sequences of actions to achieve some goal state. The point of this method of AI programming is such that it "discovers" its own actions based on how the agent is embedded in the environment. If you really want to design a specific sequence of actions, you should fine-tune the environment around it to conduce such behavior.
Recall from the paper that cooperative action (flanking) is emergent behavior, not explicitly programmed into the game.
tl;dr i think the method of implementation needs to change, but not sure in what way

i agree with you.(see detailed answer)

This evening I got inspired by this paper: http://www.dphrygian.com/bin/David-Pittman-GOAP-Masters-Thesis.doc
(GOAP paired with the Command and Control Pattern)
What do you think about this solution?
Each goal has a relevance (that depends on the agent needs)
When agent1 working on the "AskAgent2ToTalk" Action, it only sends a goal recommendation to agent2. Explicit means this: The agent only sends a list of modifiers for each goal relevance (in this case it could be a bonus for the "SocialInteraction" Goal. The value depends on the relationship between the agents) and the recommend goal.
if agent2's desired goal is the recommend goal, the agent replans.


text:
How do I know how changes in the weights are changing the reward in Reinforcement Learning
I already know the basics of the basic of Machine Learning. E.g.: Backpropagation, Convolution, etc.
First of let me explain Reinforcement learning to make sure I grasped the concept correctly.
In Reinforcement learning a random-initialized network will first "play"/"do" a sequence of moves in an environment. (In this case a Game). After that, it will receive a reward $r$. Furthermore a q-Value gets defined by the engineer/hooby coder. This reward times the q-Value $q$ to the power of the  position $n$ of the action will be feeded back using BP.
So how do I know how slight chances in $\vec{w}$ are changing $rq^n$?

You have the concept slightly wrong.
This part is mostly correct:

In Reinforcement learning a random-initialized network will first "play"/"do" a sequence of moves in an environment. (In this case a Game). After that, it will receive a reward r.

Technically neural networks are not required in RL, and it is really worth studying some simple systems that don't need them. It will make everything much clearer.
A reward $r$ can be received on every time step. However, some environments will only have a single reward at the end for success or failure for a whole episode - e.g. an instance of a game like chess where a player wins or loses.
This part is where things go a bit off track:

Furthermore a q-Value gets defined by the [developer]. This reward times the q-Value q to the power of the position n of the action will be [fed] back using BP.

Q values are one type of data that can be calculated for an agent acting in a Markov Decision Process. They are also called "action values" and they are not usually defined by a developer. The q value, if correct should return the expected future sum of rewards from following a current policy. One way of writing this is:
$$q(s,a) = \mathbb{E}_{\pi}[\sum_{k=0}^{\infty}\gamma^k R_{t+k+1}| S_t=s, A_t=a]$$
In natural language, the q value for state s and action a is the expected value (when following the given policy) of the discounted sum of rewards, starting from the given state and action. The discount factor, $\gamma$ can take any value from $0$ up to $1$, but only strictly episodic problems (which always terminate) should use the value $1$
A developer does not get to define that (except they might get to choose reward system and value of $\gamma$). Instead, they need to implement something that estimates the value of $q(s,a)$ based on what the agent has experienced. There are a few different algorithms that can do this. A popular one is called Q learning.
Regarding "[fed] back using BP", this is correct if you are using a neural network. Typically in DQN (Q learning with neural networks), this just consists of creating a small sample of training data from recent experience and training the neural network almost identically to supervised learning.

So how do I know how slight chances in $\vec{w}$ are changing $rq^n$?

Definitely don't use $rq^n$ - there is no purpose to that quantity in RL. Instead for value-based RL, you are mostly interested in your estimate for Q value. This might be written $\hat{q}(s,a,\vec{w}) \approx q(s,a)$.
However, in general your question stands. If you have implemented a neural network to learn q values, how do you know if it is working?
There are actually two parts to this problem:

How do you know whether the agent is getting better at it's task?
How do you know whether the q values are getting more accurate?

What you need to do is measure, and maybe plot some relevant quantities.
For the first question, you would typically plot the total reward that the agent gets each episode. This will be noisy, so it is a good idea to smooth it out by taking some kind of moving average (e.g. average total reward over last 100 episodes).
For the second question, it is normal to plot some loss function of the network, just like supervised learning. Typically this is Mean Squared Error loss, as the network is learning a regression to predict q values given $s$ and $a$.  You can compare observed sums of discounted reward (aka "return" or "utility") with the earlier predicted ones, and take the error function. You need to get some measure of a "true" value of q - usually a noisy sample taken during training or testing, and measure loss. For MSE that might be
$$J(\vec{w}) = \frac{1}{2|D|}\sum_{(s,a) \in D}(\hat{q}(s,a, \vec{w}) - q(s,a))^2$$
Where $D$ is some dataset you have put together of $s,a$ and $q(s,a)$ measurements to test with. If this looks familiar to you from supervised learning MSE loss, then that's correct - it is essentially the same thing, just different how you go about collecting the data.
You may expect the loss function for $\hat{q}$ in Q learning to be somewhat unstable as the agent learns. That's because in Q learning, the policy is updating at the same time as the estimates are improving. Which makes the estimates out-of-date. However, it should still be possible to see a reduction in error as learning progresses. If it becomes stable at a relatively low value compared to initially, then the agent has probably learned all that it can - although sometimes new discoveries by the agent can open up more improvements, even late in training, and throw the error function out again.
Note that a low value of the error function does not mean you have an optimal agent. It means that the value function estimate is good for how the agent is currently behaving. In turn that means the agent cannot make further improvements without new and different experience.

Thanks for this for-me-deep-enough explanation. I certainly understood what was my fault! Although this mathematic is in the moment a little bit deep for me and I am not quite sure how to read the equations, I will certainly go one.
Have an awesome day!


text:
What are the current trends/open questions in logics for knowledge representation?
What are the future prospects in near future from a theoretical investigation of description logics, and modal logics in the context of artificial intelligence research?


text:
Is it necessarry to create theory/infrastructure to prevent people from creating AI incompatible with a safe model (if we create one)?
Nowadays we don't know how to create AI in a safe way (I think that we don't even know yet how to define a safe AI), but there is a lot of research in developing a model allowing it.
Let's say, that someday we discover such a model (maybe even it would be possible to mathematically prove its safety). Is it rational to ask, how do we prevent people from creating AI outside of this model (e.g. they are so confident in their own model, that they just pursue it and end up with something like paperclip scenario)?
Should we also think about creating some theory/infrastructure preventing such a scenario?

"Nowadays we don't know how to create AI in a safe way" Nowadays we don't know how to create AI, dot. Current talks about rules to impose an unknown control model to unknown AIs are not empirical, not scientific, not true research.

It seems impossible to prevent that. If someone can make a safe AI from scratch in the near future, then someone else can make a dangerous AI from scratch as well. If all that's needed is a computer (or eventually a robot) it will be really hard to stop people from creating one.
Banning computers? Maybe it could prevent it, but that comes with quite a few negative sides as well.
A law against creating AIs? Would be really hard to follow-up, and what about the AIs people want to make to be used for something "good"?
And even if we could come up with a good set of laws they probably wouldn't be introduced in all countries, and also be really hard to follow up.
I guess we just need to make our own defence mechanisms which can fight unsafe AIs (physically or virtually) when that time comes.


text:
Convolutional Layers on a hexagonal grid in Keras
Keras' convolutional and deconvolutional layers are designed for square grids. Is there was a way to adapt them for use in hexagonal grids?
For example, if we were using axial coordinates, the input of the kernel of radius 1 centered at (x,y) should be:
[(x-1,y), (x-1,y+1), (x,y-1), (x,y+1), (x+1,y-1), (x+1, y)]
One option is to fudge it with a 3 by 3 box, but then you are using cells at different distances.
Some ideas:

Modify Kera's convolutional layer code to use those inputs instead of the default inputs. The problem is that Kera calls its backend instead of implementing it itself, which means we need to modify the backend too.
Use a 3 by 3 box, but set the weights at (x-1,y-1) and (x+1,y+1) to zero. Unfortunately, I do not know how to permanently set weights to a given value in Kera.
Use cube coordinates instead of Axial coordinates. In this case, a 3 by 3 by 3 box will only contain the central hex's neighbors and inputs set to 0. The problem is that it makes the input array much bigger. Even more problematic, some coordinates that correspond to non-hexes (such as (1,0,0)) will be assigned non-zero outputs (since (0,0,0) falls within its 3 by 3 by 3 box).

Are there any better solutions?

Related

for pytorch there is hexagdly with nice explanations

I had a similar problem with a 2D convolution on a hexagonal grid while working on a diffusion problem and stumbled upon this question. Rather than using cube coordinates, you could use doubled coordinates, which I found much easier to save in a 2D array.
An example kernel that only changes the direct neighbours and the cell itself would be this
kernel = np.array([[0,   0.1, 0,   0.1, 0  ],
                   [0.1, 0,   0.4, 0,   0.1],
                   [0,   0.1, 0,   0.1, 0  ]])

I don't know much about Keras, but I assume that this is possible there as well.


text:
How can I use A.I/Image Processing to construct mathematical graphs from drawing?
In physics, there are a lot of graphs, such as 'velocity vs time' , 'time period vs length' and so on.
Let's say I have a sample set of points for a 'velocity vs time' graph. I draw it by hand, rather haphazardly, on a canvas. This drawn graph on the canvas is then provided to the computer. By computer I mean AI.
I want it to sort of beautify my drawn graph, such as straightening the lines, making the curves better, adding the digits on axes and so on. In other words, I want it to give me a better version of my drawn graph which I can readily use in, say, a word document for a report.
a) Is it possible/plausible to do this?
b) Are there any APIs available that can already do this? (Don't want to reinvent the wheel)
c) Any recommendations/suggestions to make the idea possible by altering it somehow?

All you need is software package,so I would kindly request you to rephrase your question and post it to SoftwareRecommendationSite ,According to my analysis inline with Ai  ,Firstly.

All you need is software package,so I would kindly request you to rephrase your question and post it to SoftwareRecommendationSite ,According to my analysis inline with Ai  ,Firstly.


text:
Need Help With LSTM Neural Networks
I have been researching LSTM neural networks.  I have seen this diagram a lot and I have few questions about it. Firstly, is this diagram used for most LSTM neural networks?
Secondly, if it is, wouldn't only having single layers reduce it's usefulness?

Just to be 100% sure - the diagram you refer to is a diagram of an LSTM CELL, not NETWORK. The operands you see on the diagram are operations within a cell, not separate "neurons". I think it is quite obvious, however reading your questions I just wanted to be 100% sure we are on the same page.
Now, about layers. RNN networks (LSTM in particular) are just like any other ANN structure. Theoretically, a 1-hidden layer network can do any computation of a "deeper" network. ANN is a universal approximate of math functions. Still, multi-layer ANNs typically work better on more complex problems. Multi-layer typically needs less total connections, learns better and is less resource-demanding.
In particular, multi-layer LSTMs are believed to be better at determining complex in-time patterns. I think there is no rigorous proof for this, however.
Also, in practical applications - I did not see much improvement in network capabilities by adding additional LSTM layers. Adding more dense layers before/ after LSTM seemed to have a much better effect.

(1) Yes this is the diagram for a classical LSTM unit. Of cause there are some variants and those diagrams would look slightly different.
(2) It is very common for researchers to use more than one layers of LSTM and achieves better performance than a single layer one. A common way to "stack" LSTMs is to use the previous layer's output ($h_t$ in your diagram) as the input to the next layer ($x_t$). However, I have seldom seen any successful application of 5+ layers of LSTMs, while for CNNs it is common to use tens or even hundreds of layers.


text:
What are the most challenging tasks aiming to achieve the lowest error rate?
For example there is the MNIST database which is used to test artificial neural network (ANN), however it's not so challenging, because some hierarchical systems of convolutional neural networks manages to get an error rate of 0.23 percent.
Are there any similar, especially the most challenging tasks with dataset which are used as benchmark tests to challenge the AI which are fairly reliable and it's possible to pass, but most AAN are struggling to achieve the lower error rate?

In the field of game playing Ai the next challenge (after Go) is Starcraft.

See also: The HASYv2 dataset (my paper). The data is similar to MNIST, but 369 classes. The best model has an accuracy of ~82%.

Yes. Here are some of the most prominent ones and their respective state-of-the-art errors:

CIFAR-10: ~3.5% error
CIFAR-100: ~24% error
STL-10: ~26% error
SVHN: ~1.7% error
ImageNet tasks: the best 2012 classification task solution got 15% top-5 error, better results are currently available

You can check an updated list of solutions here. Also, a more comprehensive list of modern datasets can be found here.

The most competitive ILSVRC 2012 recently got a 3% top-5 error, see Inception-v4 paper. It has been below 15% for a long time actually.


text:
How to calculate the optimal placements for settlements in Catan without an ML algorithm?
Is it possible to calculate the best possible placements for settlements in Catan without using an ML algorithm?
While it is trivial to simply add up the numbers surrounding the settlement (highest point location), I'm looking to build a deeper analysis of the settlement locations. For example, if the highest point location is around a sheep-sheep-sheep, it might be better to go to a lower point location for better resource access. It could also weight for complementary resources, blocking other players from resources, and being closer to ports.
It seems feasible to program arithmetically, yet some friends said this is an ML problem. If it is ML, how would one go about training, as the gameboard changes every game?

Could you be a little clearer on your definition of "best"? There are a few choices, but ones suitable for analysis usually focus on a precisely-defined measure. If your measure is "most likely to win the game ultimately" then that is a hard problem and there are lots of dependencies - critical is how the agent you are deciding for and the other players intend to play the game. Often an assumption of optimal play throughout is used, but is hard to define for games with greater than 2 players.

Catan is actually a much more complicated game than the simple rules would suggest, and an exact solution is probably beyond the scope of current AI techniques.
Monte Carlo Tree Search or Expectiminimax techniques seem like they could help, but are intended for games of perfect information. Catan is not a game of perfect information (the development cards are hidden), and also has a phase that occurs without a regular turn sequence (trading).
To solve Catan properly, I think you're going to need both algorithms for solving POMDPs (like CFR+), and algorithms for negotiation (like Kraus' Diplomat). I'm not certain that these have been combined before in formal analysis, so this might actually be a good PhD thesis for someone.
That said, you can probably get a good player using self-play techniques, because Catan has randomization, and a relatively small set of moves, like Backgammon. These may or may not offer simple rules about how-best to play the game. Your friends are right to think about this as, at root, an ML problem.

Is it not inaccurate to say that the game has imperfect information? You can keep track of what development cards the other players have, by paying attention to their yields and expenses, could you not?

@Krrrl You can keep track of how many cards they have, but the cards are drawn randomly from a deck, and then concealed in players' hands. You can track how many cards of each kind have been played, and so you can guess at what a card in someone's hand might be, based on that and on what they might be trying to buy or not. However, since you can't know for sure until the card is played, this is a game of imperfect information (that's the definition).

I know the definition, but I am still arguing that since both die roll and settlement location is known at all times, you can infer what cards are in the other players hands at all time.
Example: If exactly one turn has passed - where the value rolled was 6 - then you know that players with settlements on a "6" hex has received development cards for that area, lets say brick. If none of those players proceed to build something that requires brick that turn, you now know that their hand contains 1 brick, and so on.
Could it be that we are talking about different versions of Catan?

@Krrrl It sounds like you have confused resource cards with development cards. Resource cards are awarded when dice are rolled. Development cards are purchased, and drawn face down from a shuffled deck. They are present in the base game, and all expansions.

Ah, indeed I have! I also completely forgot about the variety of development cards(non-victory points ones). I concur with your statement about imperfect information, my apologies!

Historically, the non-ML approach would be an expert system.  This is typically a rules-based decision system, falling under the umbrella of symbolic AI.
These systems can have strong utility in limited contexts, but are generally "brittle" in that parameters not previously defined or accounted will produce no-compute or weak utility. Because the rules of a game are fully definable, the main concern is utility, which relates to the degree to which the game has been solved.
Informing a heuristic system in this case requires analysis of the game in in the sense of game theory and combinatorial game theory, since Catan involves both imperfect information and combinatorial elements.  The complexity is high indeed, not only per imperfect information, branching factors, stochasticity, players > 2, but, as you note, the game board itself has a very high number of potential configurations, so solving the game is presumed to be extremely difficult to impossible.  (Possibly NEXPTIME if finite and undecidable otherwise.)
The paper Game strategies for The Settlers of Catan suggests that the game tree for Catan is not surveyable b/c the options for trade negotiation in natural language aren't bounded:

One response to this is to develop a symbolic model consisting of heuristic strategies for playing the game. Developing
  such models potentially has two advantages. First, a symbolic
  model can in principle lead to an interpretable model of human
  expert play ... Second, a symbolic model can provide
  a prior distribution over which next move is likely to be
  optimal...

The paper mentions this second part to relation to machine learning, where "the posterior distribution over optimal actions acquired through training improves on the baseline prior distribution."
Especially where the game is unsolved and intractable, machine learning has demonstrated strong utility for an increasing number of games, so it is unlikely not to be an optimal component for truly strong play.  However, such a system can be a combination of ML and domain specific knowledge, such as in informed search.
The Optimizing UCT for Settlers of Catan goes into this in detail, and also provides reference to prior work.
If your primary requirement is strong utility, some form of machine learning is likely optimal.  But it can be fun to attempt to solve games and cobble together sets of heuristics.

Nice answer. I'm not sure about the claim of NEXPTIME though. I can easily see how it is in NP, but apart from the Natural Language component, it's not clear to me that we can be sure about the hardness of the game.

@JohnDoucette Yeah, I was just making a guess based on Constraint Logic for an imperfect information team game (here "team" b/c player >2, which can result in coalitions.)  I suspect proving it would be daunting indeed, and it doesn't even show up on this wiki chart of hardness of popular games!

From the way you have phrased your question one can derive a couple of strong assumptions which simplify the problem tremendously and make it feasable:

We do not look for an agent being able to play the game but only an evaluation of settlement options (no other agents to be considered)
The evaluation of settlement options is static (i.e. does not change over time) and is independent of other settlements

From that two simple ideas come to my mind:
1. the ML approach
Look at historical game data and see which settlement options led to a win. So basically look at tuples of (X,y) with X being something like (W8, C2, O6) meaning that the settlement give access to wood with an 8, clay with a 2 and ore with a 6. And y indicating a win or loss.
To make it a bit dynamic you could differentiate between initial settlements (being placed at the beginning) and the ones during the game. So for each of these two categories you would derive basically a score for the possible settlements.
If you can compute all the possible combinations you will not even need ML since you can simply run the math once and then look it up. Might be doable in this case as the assumptions mentioned above simplify the problem a lot (compared to fully "solving" the game). Thinking through the possible combinations for a given settlement location (selecting 3 fields with A possible resources and B possible numbers) will quickly give you an idea about that.
2. The classy symbolic approach
What comes to my mind right away is linear programming as it offers a convenient way to model the strategic aspects you have mentioned. You could develop a target function to maximize using scores for different resources and numbers (e.g. you could give clay higher importance than wool). Besides that constraints can capture additional aspects of game strategies like "always make sure to have access to clay" or "do not settle where the 3 resources are the same" etc.
My very first idea to model this is using decision variables like X_(i,j) with X being 0 or 1, i representing the resources out of {clay, wood, ..., desert} (side note: do not forget the water and different ports here) and j modelling the numbers out of {2,...12}. The constraints would need to model the fact that you need to select 3 of those X_(i,j) for every settlement.
If you want to calculate this for a given game you would need to feed the model the possible settlement options based on the layout of that specific game. Then run the optimization and it gives you the best settlement option (i.e. the 3 feasable X_(i,j) maximizing your goal function).
Qua definition you need to bring in game knowledge for this approach. And probably talking to someone who is really good at the game would help to understand what matters.


text:
Optimization step in Apprenticeship Learning via Inverse Reinforcement Learning
Why the optimization step of the algorithm a quadratic program?  [See: Apprenticeship Learning via Inverse Reinforcement Learning; page 3]
Isn't the objective function linear? Why don't we treat the problem as LPQC (linear program with quadratic constraints)?

Could you perhaps include a link to a relevant paper? It looks like you have a very specific algorithm in mind, and if you can link to it, others will be better able to help.

https://ai.stanford.edu/~ang/papers/icml04-apprentice.pdf

the algorithm is in the 3rd page


text:
Is there a database somewhere of common lists?
I'm looking for a database or some machine readable document that contains common ordered lists or common short sets. e.g:
{January, February, March,...}
{Monday, Tuesday, ....}
{Red, Orange, Yellow,...}
{1,2,3,4,...}
{one, two, three, four,...}
{Mercury, Venus, Earth, Mars,...}
{I, II, III, IV, V, VI,...}
{Aquarius, Pisces, Aries,...}
{ein, zwei, drei, ...}
{Happy, Sneezy, Dopey, ...}
{Dasher, Dancer, Prancer, Vixen ,...}
{John, Paul, George, Ringo}
{20, 1, 18, 4, 13, 6, ...}
{Alabama, Alaska, Arizona, Arkansas, California,...}
{Washington, Adams, Jefferson, ...}
{A,B,C,D,E,F,G,...}
{A,E,I,O,U}
{2,3,5,7,11,13,17,...}
{triangle, square, pentagon, hexagon,...}
{first, second, third, fourth, fifth,...}
{tetrahedron, cube, octohedron, icosohedron, dodecahedron}
{autumn, winter, spring, summer}
{to, be, or, not, to, be, that, is, the, question}
...

One use is for creating an AI that can solve codes or predict the next thing in a sequence.

I've provisionally added a new tag for "resource-requests" because I can see how access to such the types of datasets you're looking for could be useful to others looking to create or train algorithms.

I think this question is on-topic, in disagreement with the current close-vote. In fact, one of the most important open point in AI is how an AI system can establish relations between concepts. In fact, this one is on-topic, 99% of the question about neural net implementations are not.

Questions asking for datasets or tools, such as software libraries or APIs, are off-topic here. We focus on the theoretical, social and philosophical aspects of artificial intelligence (so this excludes recommendations of software libraries). If you're looking for software recommendations, you should ask your question here: https://softwarerecs.stackexchange.com/. If you're looking for datasets, you probably should ask it on Open Data SE.

So here’s a couple quick resources that i could think of.  First of all, you could look at this,
https://en.m.wikipedia.org/wiki/List_of_lists_of_lists
It has classics such accidents,  hospitals in Asia, or even a list of famous resignations. It’s easentially a list of random lists of things.  It may not owner cover your requirement for sequences but it’ll help with small subsets of lists.
As for sequences, you could always check out,
https://oeis.org
It’s pretty much a list of official mathematical sequences.  It’s got everything from the Fibonacci sequence to esoteric sequences you’ve never heard of.


text:
Simple question about HS algorithm's formul(Optical flow)
In the below pic, I can not understand what U vector is? It says flow field but I can not imagie what really is the flow field?


text:
What are the advantages of ReLU vs Leaky ReLU and Parametric ReLU (if any)?
I think that the advantage of using Leaky ReLU instead of ReLU is that in this way we cannot have vanishing gradient. Parametric ReLU has the same advantage with the only difference that the slope of the output for negative inputs is a learnable parameter while in the Leaky ReLU it's a hyperparameter.
However, I'm not able to tell if there are cases where is more convenient to use ReLU instead of Leaky ReLU or Parametric ReLU.

Combining ReLU, the hyper-parameterized1 leaky variant, and variant with dynamic parametrization during learning confuses two distinct things:

The comparison between ReLU with the leaky variant is closely related to whether there is a need, in the particular ML case at hand, to avoid saturation — Saturation is thee loss of signal to either zero gradient2 or the dominance of chaotic noise arising from digital rounding3.
The comparison between training-dynamic activation (called parametric in the literature) and training-static activation must be based on whether the non-linear or non-smooth characteristics of activation have any value related to the rate of convergence4.

The reason ReLU is never parametric is that to make it so would be redundant.  In the negative domain, it is the constant zero.  In the non-negative domain, its derivative is constant.  Since the activation input vector is already attenuated with a vector-matrix product (where the matrix, cube, or hyper-cube contains the attenuation parameters) there is no useful purpose in adding a parameter to vary the constant derivative for the non-negative domain.
When there is curvature in the activation, it is no longer true that all the coefficients of activation are redundant as parameters.  Their values may considerably alter the training process and thus the speed and reliability of convergence.
For substantially deep networks, the redundancy reemerges, and there is evidence of this, both in theory and practice in the literature.

In algebraic terms, the disparity between ReLU and parametrically dynamic activations derived from it approaches zero as the depth (in number of layers) approaches infinity.
In descriptive terms, ReLU can accurately approximate functions with curvature5 if given a sufficient number of layers to do so.

That is why the ELU variety, which is advantageous for averting the saturation issues mentioned above for shallower networks is not used for deeper ones.
So one must decided two things.

Whether parametric activation is helpful is often based on experimentation with several samples from a statistical population.  But there is no need to experiment at all with it if the layer depth is high.
Whether the leaky variant is of value has much to do with the numerical ranges encountered during back propagation.  If the gradient becomes vanishingly small during back propagation at any point during training, a constant portion of the activation curve may be problematic.  In such a scase one of the smooth functions or leaky RelU with it's two non-zero slopes may provide adequate solution.

In summary, the choice is never a choice of convenience.

Footnotes
[1] Hyper-parameters are parameters that affect the signaling through the layer that are not part of the attenuation of inputs for that layer.  The attenuation weights are parameters.  Any other parametrization is in the set of hyper-parameters.  This may include learning rate, dampening of high frequencies in the back propagation, and a wide variety of other learning controls that are set for the entire layer, if not the entire network.
[2] If the gradient is zero, then there cannot be any intelligent adjustment of the parameters because the direction of the adjustment is unknown, and its magnitude must be zero.  Learning stops.
[3] If chaotic noise, which can arise as the CPU rounds extremely small values to their closest digital representation, dominates the correction signal that is intended to propagate back to the layers, then the correction becomes nonsense and learning stops.
[4] Rate of convergence is a measure of the speed (either relative to microseconds or relative to the iteration index of the algorithm) in which the result of learning (system behavior) approaches what is considered good enough.  That's usually some specified proximity to some formal acceptance criteria for the convergence (learning).
[5] Functions with curvature are ones that are not visualized as straight or flat.  A parabola has curvature.  A straight line does not.  The surface of an egg has curvature.  A perfect flat plane does not.  Mathematically, if any of the elements of the Hessian of the function is non-zero, the function has curvature.

What do you mean by The choice is never a choice of convenience?

@gvgramazio, You had written, "more convenient to use ReLU," in your question. I was indicating that convenience is not the basis on which the choice is made. Perhaps it comes off as too harsh? I didn't intend to be. The sentences above that sentence in my answer were intended to provide the more useful criteria upon which you might base your decision when choosing activation functions.

Don't worry about being too harsh, not a problem at all for me. I think that is more a problem of language (I'm not a native English speaker).

The fact is that, from what I've understood, you explain well in which case I should prefer one variant with respect to the other ones. What I still don't understand is when I should prefer the classical one. e.g. the leaky variant may provide an adequate solution to vanishing gradient but if it hasn't any drawback I could always choose the leaky variant with respect to the ReLU.


text:
Multiple sets of input in Neural network (or other form of ML)
I'm currently working on a research project where I try to apply different kinds of Machine Learning on some existing software I wrote a few years ago.
This software will scan for people in the room continuously.
Some of these detections are either True or False. However, this is not known, so I cannot use supervised learning to train a network to make a distinction.
I do however have a number that is correlated to the number of detections that should be True in a given period of time (let's say 30 seconds - 2 minutes), which can be used as an output feature to train a regression model.
But the problem is... How can I give these multiple "detections" as an input?
The way I see it now, would be something like this:
+--------------------------------------------------------------+-----------+------------+------------+----------------+--+
|                          Detections                          | Variable1 | Variable 2 | Variable n | Output Feature |  |
+--------------------------------------------------------------+-----------+------------+------------+----------------+--+
| {person a, person b, person h, person z}                     |       132 |        189 |          5 |             50 |  |
| {person a, person b, person c, person d, person k, person m} |         1 |         50 |        147 |             80 |  |
| {person c, person e, person g, person f}                     |       875 |        325 |          3 |             20 |  |
+--------------------------------------------------------------+-----------+------------+------------+----------------+--+

Each of these persons would be a tuple of values: var_1, var_2, var_3, var_4.
These values are not constant however! They do change between observations.
Different approach to explain it: there's multiple observations (variable amount) in each time segment (duration of time segment is a fixed integer to be chosen). These observations have a few variables that would indicate whether the observation is true or false. However, the threshold for it being true or false, is very much dependant on the other variables, that are not tied to the information of the persons. (These variables are the same for all of them, but vary in between time segments. Let's call'm "environment features")
Lastly, the output feature is the product of the count of persons that resulted in "True" and a (varying) factor that is correlated to the environment features.
So I've been thinking about probabilistic AI, but the problem is that there isn't a known distribution between True/False.

Is there any technique I can apply to be able to use this kind of data
as an input of a Neural Network (or other forms of ML)? Or is there a
specific form of ML that is used for this kind of problems?

Thanks in advance!


text:
If use the weights from previous iteration of a k-fold cross validation to seed a neural network classifier would I be overfitting?
As is done traditionally, I used k-fold cross validation to select and optimize the hyper parameters of my neural network classifier. When it was time to store the final model for future predictions, I discovered that using the weights from the previous k-fold cv iteration to seed the initial weights of the model in subsequent iteration, helps in improving the accuracy (seems obvious). I can use the model from the final iteration to perform future predictions on unseen data.

Would this approach result in overfitting?

(Please note, I am using all available data in this process and I do not have any holdout data for validation.)

To answer directly your question: estimating a model's performance on data previously used for fitting will overestimate performance.
When your dataset is "small" you are faced with a bias-variance dilemma with regards to how much data should be used for train and test sets:

Too much train data, you end up with little test samples and your
performance estimate has high variance.
Too much test data, your train samples do not represent well the
population you are trying to model/target, so your average
performance will be much lower than what could be achieved.

K-fold CV is a compromise in the evaluation of performance of certain procedure. Once you have settled on a certain model or hyperparameters, when moving to production you can:
Choose to take one of the k models you have trained, perhaps using the "one std variation rule of thumb".

Re-train on all of your data and you can expect the resulting model
to be at least as good as you have estimated.
Use all k models to form an ensemble and you can expect the resulting
model to be at least as good as you have estimated.

Thank you for your response. Some additional clarification. I am not evaluating the performance of my model. I have use the K-fold CV in the traditional way during training. For production use, I have choice between the two options that you have provided in the last paragraph - or a third option: which is what I have described. I suspect that since both approaches (your option 1 and my option 3) use all the available data, the models coming out this process would be similar. But do such models deviate significantly from the initial models trained using only part of the data?


text:
Defining formula for fuzzy equation
I'm learning fuzzy logic and more or less understand the basic concept, but i'm having a hard time understanding how to apply it to a method. I tried browsing online for explanation on how to use it, but only found some implementation and test case using the basic form of 4 rules and 3 variables, and 2 rules per variable. Anyway this is an example case, i will use Tsukamoto method.
In this case actually i have 6 rules and 3 variables with 3 rules ver variable, but i will only explain 1 of the variables because i think the rest will have the same solution. I have 3 variables one of them is "size", the range is for small it's 0-2 and for large it's 7-10. The current condition is size = 6.5. The rules is as follow(simplified to only use this variable):

[R1] size = small
[R2] size = medium
[R3] size = large

What i want to know is:

how do i define the formula for medium(the middle rule if the case is different)?
what if the rule is more than 3 (i.e. small, medium, large, ex-large)?

What i understands if the rule is only 2 i can use this formula

small[x]=(max-x)/(max-min)
large[x]=(x-min)/(max-min)

My current approach to this problem is as follow:
small[x]=1; x<=2
medium[x]=(max-x)/(max-min); 2 < x < 7
large[x]=0; x>=7
Is this correct? Also can you refer me to some source to study this? As i mentioned before i can only find some implementation and basic explanation, it's either there is no online source for this or i don't know what to search for. Sorry if it's hard to understand i can edit and post the whole problem if you want, thanks in advance.
Extra question: what is the name of algorithm which can be used to solve the crossing bridge puzzle(the one with timer, max person, and stuff)?i forgot the name.

Is the question about understanding the Tsukamoto method? The method applies to n multivariate rules, but first, it is not clear how you applied the method here.

No it's the membership graph and function that I don't understand. I am confused at what function/formula should i use and what values should i add to the function if the value of a variable is a range in above example large = 7-10. I know a bit to proceed after that, only the basic though but I want to understand this one first.

After i did a bit more study on this, i found this solution.

μsmall[x]

1; -> x≤0
(20-x)/(20-0); -> 0
0; -> x≥20

μmedium[x]

0; -> x≤20 or x≥70
(x-20)/(45-20); -> 20
(70-x)/(70-45); -> 45

μlarge[x]

0; -> x≤70
(x-70)/(100-70); -> 70
1; -> x≥100

For the final result i need to add 3 more rules for the function to work. So it become 9 rules and 3 variables, with 3 rules for each input variables.
To answer both of my question:

Add a triangle graph and use the formula.
Add a triangle graph for each rules.

What i learn from this is the total rules needed to determine the output is the number of input variables rules multiplied(i.e. v1 = 3 rules, v2 3 rules, total rules = 3x3=9 rules). And i'm not really sure about this one but you can combine multiple kind of graphs.

I know this is a bad practice because it's basically asking clarification for my answer. But because i'm still new at this and not really sure about my answer, i will mark my answer as accepted after someone can verify it.

I think maybe you are overthinking it, it's been a while since I have done fuzzy logic but the answer you have given seems to be correct from what I can tell. At university when I have done this in the past you only usually give the answer you have given in that format exactly then just do a brief explanation. I can't add this as a comment due to a low score here as I am new, but hopefully, my personal experience helps somewhat here, if not I can provide more sources of information to help clarify, but honestly I do find the trick with this is to not overthink it.

authors: ลุกมาล พิมพาเลีย


text:
Which photo is more artistic?
I would like to develop a machine learning algorithm, given two photos, that can decide which image is more "artistic".
I am thinking about somehow combining two images, giving it to a CNN, and get an output 0 (the first image is better) or 1 (the second image is better). Do you think this is a valid approach? Or could you suggest an alternative way for this? Also, I don't know how to combine two images.
Thanks!
Edit: Let me correct "artistic" as "artistic according to me", but it doesn't matter, I am more interested in the architecture. You can even replace "artistic" with something objective. Let's say I would like to determine which photo belongs to a more hotter day.

@DuttaA Art History is the general field for this, subfield photography. :) Composition is perhaps the primary qualities, but others would be contrast, lighting, focus, etc. and more subtle concepts such as "telling a story" or "capturing a moment".

It is Simple by lighting the image with the datamodel expose the original image with the generated one

You need to define a scoring function, which returns a value of whatever criterion you are interested in, be it 'artisticity' or 'heat'. This could be something you use a machine learning algorithm for, provided you have a set of training data with labelled images.
You then need to extract features from the images. In the case of 'heat' this could be a colour spectrum (ie distribution of colours across the image), or whatever. If it's a reasonably small image, pixel values might be feasible. These features you can feed into your algorithm, and try to learn an association between the feature values and the (assigned by you) label of the image. You will end up with a classifier that takes image features as input, and returns the labels as output. The quality of the classifier depends on your images, the features you selected, and the task.  If there is no structure in the data, then a classifier will not work properly.
If you have a continuous value (eg temperature in degrees C) you would run your two sample images through the classifier, and then compare the output values.

For a CNN this is the way to go. May be worth mentioning that "provided you have a set of training data with labelled images" probably requires many 1000s of labelled images that the OP needs to source somehow.

I think the real problem is, what defines a more artistic image? It's really subjective, I think complexity of the work might be one aspect to consider but still a subjective one, you might want to make the purpose of your ML algorithm more objective or defined.
But then again, It's just my opinion

Yes, I totally agree but assume I would like to build something "artistic according to me".

My feeling is that, because you are dealing with a subject that his highly subjective, you need to integrate whatever learning algorithm you use with human feedback.
This is to say, crowdsource human opinions on a data set of pictures, train the algorithm to try to intuit what qualities images with similar human rankings share. (Both the positive and negative rankings.) Run the algorithm on a new data set and crowdsource that data set to see if the algorithm gets it right.  Rinse & repeat.
You may also want to utilize demographics in the human crowdsourcing.  Art historians will likely have different criteria for what makes a photo artistic than the general public.  Humans with different educational backgrounds will likely have different criteria for what makes a photo artistic.
Sans the crowdsourcing, the algorithm will have no ability to determine the aesthetic qualities other than what the programmer defines, and in that case, the algorithm will only be able to determine what photos are artistic to the programmer, limiting the utility.


text:
Is a mathematical formula a form of intelligence?
Warning: This question takes us into VALIS territory, but I wouldn't underestimate the profundity of that particular philosopher.
There is a non-AI definition of intelligence which is simply "information" (see definition 2.3).  If that information is active, in terms of utilization, I have to wonder if it might qualify as a form of algorithmic intelligence, regardless of the qualities of the information.
What I'm getting at is that fields such as recreational mathematics often produce techniques and solutions that don't have immediate, real world applications.  But there's an adage that pure math tends to find uses.
So you might have algorithms applied to a problems that outside of the problems from which it originated, or that couldn't initially be implemented in a computing context. (Minimax in 1928 might be an example.)
Goal orientation has been widely understood as a fundamental aspect of AI, but in the case of an algorithm designed for one problem, that it subsequently applied to a different problem, the goal may simply be a function of the algorithm's structure. (To understand the goal of minimax precisely, you read the algorithm.)
If you regard this form of information as intelligence, then intelligence can be general, regardless of strength in relation to a given problem.

Can we consider this form of codification of information to be algorithmic intelligence?

And, just for fun, if a string that encodes a cutting-edge AI is not being processed, does it still qualify as artificial intelligence?

Could you explain what you mean by the last question a little more?

@AndrewButler We tend to think of intelligence as applied.  An AI is an applied algorithm that makes decisions with the goal of achieving more optimal results.  But if the program is not running, say it's just the paper printout of the algorithm, is it still an intelligence?  (Admittedly a bit of a curve ball, but this is squarely a philosophical question about what we regard as intelligence.)

@AndrewButler but admittedly, the ultimate question is in the realm of "am I a man dreaming of being a butterfly, or a butterfly dreaming of being a man?"  One of the most salient features of Dick's work is that nearly all his books are about the nature of self in relation perception, and how perception governs subjective reality.  It's a profound comment on the informational conception of the universe, which does have some traction in serious circles. A recurrent aspect of Singluarity mythology is the interchangeability of matter and information.


text:
What kind of simulated environment is complex enough to develop a general AI?
Imagine trying to create a simulated virtual environment that is complicated enough to create a "general AI" (which I define as a self aware AI) but is as simple as possible. What would this minimal environment be like?
i.e. An environment that was just a chess game would be too simple. A chess program cannot be a general AI.
An environment with multiple agents playing chess and communicating their results to each other. Would this constitute a general AI? (If you can say a chess grand master who thinks about chess all day long has 'general AI'? During his time thinking about chess is he any different to a chess computer?).
What about a 3D sim-like world. That seems to be too complicated. After all why can't a general AI exist in a 2D world.
What would be an example of a simple environment but not too simple such that the AI(s) can have self-awareness?

I will skip all thematic about "what is an AGI", "simulation game", ... These topics have been discussed during decades and nowadays they are, in my opinion, a dead end.
Thus, I can only answer with my personal experience:
It is a basic theorem in computing that any number of dimensions, including temporal one, in a finite size space, can be reduced to 1D.
However, in practical examples, the 1D representation becomes hard to analyze and visualize. It is more practical work with graphs, that can be seen as an intermediate between 1D and 2D. Graphs allows representation of all necessary facts and relations.
By example, if we try to develop an AGI able to work in the area of mathematics, any expression (that humans we write in a 2D representation with rationals, subscripts, integrals, ...) can be represented as 1D (as an expression written in a program source) but this 1D must be parsed to reach the graph that can be analyzed or executed. Thus, the graph that results after the parsing of the expression is the most practical representation.
Another example, if we want an agent that travels across a 3D world, this world can be seen as an empty space with objects that have some properties. Again, after the initial stage of scene analysis and object recognition (the equivalent to the parser in previous example), we reach a graph.
Thus, to really work in the area of AGI, I suggest skip the problems of scene analysis, object recognition, speech recognition (Narrow AI), and work directly over the representative graphs.

It's interesting you talk about graphs. Because my instinct was telling me that some kind of entity that navigates the nodes of a graph would might be complex enough. But I worry that a finite graph with finite things going on would be rather limited. But in another way, our own lives are rather limited when you think about it: eat;work;sleep;repeat. However, if the entities had to compete (or collaborate) with other entities, perhaps more complex behaviour would occur with them trying to second-guess each other.

I think the most important thing is that it has to have time simulated in some way. Think self aware chatbot. Then to be "self aware" the environment could be data that is fed in through time that can be distinguished as being "self" and "other". By that I suppose I mean "self" is the part it influences directly and "other" is the part that is influenced indirectly or not at all. Other than that it probably can live inside pretty abstract environments. The reason time is so important is without it the cognitive algorithm is just solving a math problem.

In computer theory, time is reduced to sequence of events. Thus, a 1D event (i.e. an string) that evolves in time can be seen as a 2D event (array of string) or 1D sequence (sequence of strings).

I disagree with the notion that time in the real world (or arguably for a sufficiently interesting artificial one) can be adequately dismissed as "just another dimension". One needs at least one time dimension to support any representation of entropy or change. And I would say that  any adequate representations of dynamical systems require adequate distinction of a time dimension from position. Even your representational suggestion give the ordering of the sequence a special place.

@42- Just so happens, in my efforts to formally define the topological structure of Sudoku and Latin Squares as probabilistic matrix functions using set theory, I'd hit a wall until I started looking at Hamiltonian Evolution and realized t (time, or, "turns" in the new game theoretic conception of orthogonal arrays) was the missing element!

Thinking now about dynamical systems in General Relativity. Perhaps  you need a "gravity" metric to calculate a local value potential? Would some configurations be "black holes"

General AI can absolutely exist in a 2D world, just that a generalized AI (defined here as "consistent strength across a set of problems") in this context would still be quite distinct from an Artificial General Intelligence, defined as "an algorithm that can perform any intellectual task that a human can."
Even there, the definition of AGI is fuzzy, because "which human?"  (Human intelligence is a spectrum, where individuals possess different degrees of problem solving capability in different contexts.)

Artificial Consciousness: Unfortunately, self-awareness / consciousness is a heavily metaphysical, issue, distinct from problem solving capability (intelligence).
You definitely want to look a the "Chinese Room" and rebuttals.

Probably worth looking at the holographic principle: "a concept in physics whereby a space is considered as a hologram of n-1 dimensions."  Certainly models and games can be structured in this way.
Another place to explore is theories of emergence of superintelligence on infinite Conway's Game of Life.  (In a nutshell, my understanding is that once researchers figured out how to generate any number within the cellular automata, the possibility of emergent sentience given a gameboard of sufficient size is at least theoretically sound.)

Though a good answer by @pasaba por aqui, I'd agree with @zooby that a graph might be too simplistic. If humans were in an environment where the options were drown or take 5000 unrelated steps to build a boat, we'd never have crossed any seas.
I think any graph, if designed by hand, would not be complex enough to call the agent within as general AI. The world would need enough in-between states that it would no longer be best described as a graph, but at least a multidimensional space.
I think there are 2 points you'd have to consider. What is "simple" and when would you recognise it as a "general AI". I don't find self aware AI satisfactory, as we can't measure anything called awareness; we can only see its state and its interaction with the environment.
For 1. I'd pose that the world we live in is actually fairly simple. There are 4 forces of nature, a few conservation laws, and a bunch of particle types that explain most of everything. It's just that there are many of these particles and this has led to a rather complex world. Of course, this is expensive to simulate, but we could take some shortcuts. People 200 years ago wouldn't need all of quantum mechanics to explain the world. If we replaced protons, neutrons and the strong force with the atoms in the periodic table, we'd mostly be fine. Problem is we replaced 3 more general laws with 100 specific instances. For the simulated environment to be complex enough I think this trend must hold. We could replace trillions of particles governed by general laws with thousands of instances that have different properties when interacting with the agent, and I think more importantly, when interacting with each other.
Which brings me to 2. I think we'd only truly be satisfied with the agent expressing general AI when it can purposefully interact with the environment in a way that would baffle us, while clearly benefiting from it (so not accidentally). Now that might be quite difficult or take a very long time, so a more relaxed condition would be to build tools that we'd expect it to build, thus showing mastery of its own environment. For example, evidence of boats have been found somewhere between 100k and 900k years ago, which is about the same time-scale when early humans developed. However although we'd consider ourselves intelligent, I'm not sure we'd consider a boat making agent to have general intelligence as it seems like a fairly simple invention. But I think we'd be satisfied after a few such inventions.
So I think we'd need a Sim like world, that's actually a lot more complicated than the game. With 1000s of item types, many instances of each item and enough degrees of freedom to interact with everything. I also think we need something that looks familiar to acknowledge any agent as intelligent. So a 3D, complicated, minecraft-like world would be the simplest world in which we would recognise the emergence of general intelligence.

Of the answers so far, the one from @DukeZhou were the most provocative. For instance, the reference to the Chinese Room critique brings up Searle's contention that some form of intentionality might need support in the artificial environment. This might imply the necessity of a value system or a pain-pleasure system, i.e. something where good consequences can be "experienced" or actively sought and bad consequences avoided. Or some potential for individual extinction (death or termination) might need to be recognized. The possibility of "ego-death" might need to have a high negative value.  That might imply an artificial world should include "other minds" or other agents, which the emerging or learning intelligent agent could observe (in some sense) and "reflect on", i.e recognize an intelligence like its own. In this sense the Cartesian syllogism "I think therefore I am" gets transmuted into: I (or rather me as an AI) see evidence of others thinking, and "by gawd, 'I' can, too". Those "others" could be either other learning systems (AGI's) or some contact with discrete inputs from humans mediated by the artificial environment. Wikipedia discussion of the "reverse Turing test"
The mention of dimensionality should provoke a discussion of what would be the required depth of representation of a "physics" of the world external to the AI. Some representation of time and space would seem necessary, i.e., some dimensional substructure for progress to goal attainment. The Blocks World was an early toy problem whose solution provoked optimism in the 60's and 70's of last century that substantial progress was being made. I'm not aware of any effort to program in any pain or pleasure in the SHRDLU program of that era (no dropping blocks on the program's toes), but all the interesting science fiction representations of AI's have some recognition of "physical" adverse consequences in the "real world".
Edit: I'm going to add a need for "entities with features" in this environment that could be "perceived" (by any of the "others" that are interacting with the AGI) as the data input to efforts at induction, identification, and inference about relationships. This creates a basis for a shared "experience".


text:
Genetic Algorithm - creatures in 2d world are not learning
Goal -
I am trying to implement a genetic algorithm to optimise the fitness of a
species of creatures in a simulated two-dimensional world. The world contains edible foods, placed at random, and a population of monsters (your basic zombies).  I need the algorithm to find behaviours that keep the creatures well fed and not dead.
What i have done -
So i start off by generating a 11x9 2d array in numpy, this is filled with random floats between 0 and 1. I then use np.matmul to go through each row of the array and multiply all of the random weights by all of the percepts (w1+p1*w2+p2....w9+p9) = a1.
This first generation is run and I then evaluate the fitness of each creature using (energy + (time of death * 100)). From this I build a list of creatures who performed above the average fitness. I then take the best of these "elite" creatures and put them back into the next population. For the remaining space I use a crossover function which takes two randomly selected "elite" creatures and mixes their genes. I have tested two different crossover functions one which does a two point crossover on each row and one which takes a row from each parent until the new child has a complete chromosome. My issue is that the creatures just don't really seem to be learning, at 75 turns I will only get 1 survivor every so often.
I am fully aware this might not be enough to go off but I am truly stuck on this and cannot figure out how to get these creatures to learn even though I think I am implementing the correct procedures. Occasionally I will get a 3-4 survivors rather than 1 or 2 but it appears to occur completely randomly, doesn't seem like there is much learning happening.
Below is the main section of code, it includes everything I have done but none of the provided code for the simulation
#!/usr/bin/env python
from cosc343world import Creature, World
import numpy as np
import time
import matplotlib.pyplot as plt
import random
import itertools

# You can change this number to specify how many generations creatures are going to evolve over.
numGenerations = 2000

# You can change this number to specify how many turns there are in the simulation of the world for a given generation.
numTurns = 75

# You can change this number to change the world type.  You have two choices - world 1 or 2 (described in
# the assignment 2 pdf document).
worldType=2

# You can change this number to modify the world size.
gridSize=24

# You can set this mode to True to have the same initial conditions for each simulation in each generation - good
# for development, when you want to have some determinism in how the world runs from generation to generation.
repeatableMode=False

# This is a class implementing you creature a.k.a MyCreature.  It extends the basic Creature, which provides the
# basic functionality of the creature for the world simulation.  Your job is to implement the AgentFunction
# that controls creature's behaviour by producing actions in response to percepts.
class MyCreature(Creature):

    # Initialisation function.  This is where your creature
    # should be initialised with a chromosome in a random state.  You need to decide the format of your
    # chromosome and the model that it's going to parametrise.
    #
    # Input: numPercepts - the size of the percepts list that the creature will receive in each turn
    #        numActions - the size of the actions list that the creature must create on each turn
    def __init__(self, numPercepts, numActions):

        # Place your initialisation code here.  Ideally this should set up the creature's chromosome
        # and set it to some random state.
        #self.chromosome = np.random.uniform(0, 10, size=numActions)
        self.chromosome = np.random.rand(11,9)
        self.fitness = 0
        #print(self.chromosome[1][1].size)

        # Do not remove this line at the end - it calls the constructors of the parent class.
        Creature.__init__(self)

    # This is the implementation of the agent function, which will be invoked on every turn of the simulation,
    # giving your creature a chance to perform an action.  You need to implement a model here that takes its parameters
    # from the chromosome and produces a set of actions from the provided percepts.
    #
    # Input: percepts - a list of percepts
    #        numAction - the size of the actions list that needs to be returned
    def AgentFunction(self, percepts, numActions):

        # At the moment the percepts are ignored and the actions is a list of random numbers.  You need to
        # replace this with some model that maps percepts to actions.  The model
        # should be parametrised by the chromosome.

        #actions = np.random.uniform(0, 0, size=numActions)

        actions = np.matmul(self.chromosome, percepts)

        return actions.tolist()

# This function is called after every simulation, passing a list of the old population of creatures, whose fitness
# you need to evaluate and whose chromosomes you can use to create new creatures.
#
# Input: old_population - list of objects of MyCreature type that participated in the last simulation.  You
#                         can query the state of the creatures by using some built-in methods as well as any methods
#                         you decide to add to MyCreature class.  The length of the list is the size of
#                         the population.  You need to generate a new population of the same size.  Creatures from
#                         old population can be used in the new population - simulation will reset them to their
#                         starting state (not dead, new health, etc.).
#
# Returns: a list of MyCreature objects of the same length as the old_population.

def selection(old_population, fitnessScore):
    elite_creatures = []
    for individual in old_population:
        if individual.fitness > fitnessScore:
            elite_creatures.append(individual)

    elite_creatures.sort(key=lambda x: x.fitness, reverse=True)

    return elite_creatures

def crossOver(creature1, creature2):
    child1 = MyCreature(11, 9)
    child2 = MyCreature(11, 9)
    child1_chromosome = []
    child2_chromosome = []

    #print("parent1", creature1.chromosome)
    #print("parent2", creature2.chromosome)

    for row in range(11):
        chromosome1 = creature1.chromosome[row]
        chromosome2 = creature2.chromosome[row]

        index1 = random.randint(1, 9 - 2)
        index2 = random.randint(1, 9 - 2)

        if index2 >= index1:
            index2 += 1
        else:  # Swap the two cx points
            index1, index2 = index2, index1

        child1_chromosome.append(np.concatenate([chromosome1[:index1],chromosome2[index1:index2],chromosome1[index2:]]))
        child2_chromosome.append(np.concatenate([chromosome2[:index1],chromosome1[index1:index2],chromosome2[index2:]]))

    child1.chromosome = child1_chromosome
    child2.chromosome = child2_chromosome

    #print("child1", child1_chromosome)

    return(child1, child2)

def crossOverRows(creature1, creature2):
    child = MyCreature(11, 9)

    child_chromosome = np.empty([11,9])

    i = 0

    while i < 11:
        if i != 10:
            child_chromosome[i] = creature1.chromosome[i]
            child_chromosome[i+1] = creature2.chromosome[i+1]
        else:
            child_chromosome[i] = creature1.chromosome[i]

        i += 2

    child.chromosome = child_chromosome

    return child

    # print("parent1", creature1.chromosome[:3])
    # print("parent2", creature2.chromosome[:3])
    # print("crossover rows ", child_chromosome[:3])

def newPopulation(old_population):
    global numTurns

    nSurvivors = 0
    avgLifeTime = 0
    fitnessScore = 0
    fitnessScores = []

    # For each individual you can extract the following information left over
    # from the evaluation.  This will allow you to figure out how well an individual did in the
    # simulation of the world: whether the creature is dead or not, how much
    # energy did the creature have a the end of simulation (0 if dead), the tick number
    # indicating the time of creature's death (if dead).  You should use this information to build
    # a fitness function that scores how the individual did in the simulation.
    for individual in old_population:

        # You can read the creature's energy at the end of the simulation - it will be 0 if creature is dead.
        energy = individual.getEnergy()

        # This method tells you if the creature died during the simulation
        dead = individual.isDead()

        # If the creature is dead, you can get its time of death (in units of turns)
        if dead:
            timeOfDeath = individual.timeOfDeath()
            avgLifeTime += timeOfDeath
        else:
            nSurvivors += 1
            avgLifeTime += numTurns

        if individual.isDead() == False:
            timeOfDeath = numTurns

        individual.fitness = energy + (timeOfDeath * 100)
        fitnessScores.append(individual.fitness)
        fitnessScore += individual.fitness
        #print("fitnessscore", individual.fitness, "energy", energy, "time of death", timeOfDeath, "is dead", individual.isDead())

    fitnessScore = fitnessScore / len(old_population)

    eliteCreatures = selection(old_population, fitnessScore)

    print(len(eliteCreatures))

    newSet = []

    for i in range(int(len(eliteCreatures)/2)):
        if eliteCreatures[i].isDead() == False:
            newSet.append(eliteCreatures[i])

    print(len(newSet), " elites added to pop")

    remainingRequired = w.maxNumCreatures() - len(newSet)

    i = 1

    while i in range(int(remainingRequired)):
        newSet.append(crossOver(eliteCreatures[i], eliteCreatures[i-1])[0])
        if i >= (len(eliteCreatures)-2):
            i = 1
        i += 1

        remainingRequired = w.maxNumCreatures() - len(newSet)

    # Here are some statistics, which you may or may not find useful
    avgLifeTime = float(avgLifeTime)/float(len(population))
    print("Simulation stats:")
    print("  Survivors    : %d out of %d" % (nSurvivors, len(population)))
    print("  Average Fitness Score :", fitnessScore)
    print("  Avg life time: %.1f turns" % avgLifeTime)

    # The information gathered above should allow you to build a fitness function that evaluates fitness of
    # every creature.  You should show the average fitness, but also use the fitness for selecting parents and
    # spawning then new creatures.

    # Based on the fitness you should select individuals for reproduction and create a
    # new population.  At the moment this is not done, and the same population with the same number
    # of individuals is returned for the next generation.

    new_population = newSet

    return new_population

# Pygame window sometime doesn't spawn unless Matplotlib figure is not created, so best to keep the following two
# calls here.  You might also want to use matplotlib for plotting average fitness over generations.
plt.close('all')
fh=plt.figure()

# Create the world.  The worldType specifies the type of world to use (there are two types to chose from);
# gridSize specifies the size of the world, repeatable parameter allows you to run the simulation in exactly same way.
w = World(worldType=worldType, gridSize=gridSize, repeatable=repeatableMode)

#Get the number of creatures in the world
numCreatures = w.maxNumCreatures()

#Get the number of creature percepts
numCreaturePercepts = w.numCreaturePercepts()

#Get the number of creature actions
numCreatureActions = w.numCreatureActions()

# Create a list of initial creatures - instantiations of the MyCreature class that you implemented
population = list()
for i in range(numCreatures):
   c = MyCreature(numCreaturePercepts, numCreatureActions)
   population.append(c)

# Pass the first population to the world simulator
w.setNextGeneration(population)

# Runs the simulation to evaluate the first population
w.evaluate(numTurns)

# Show the visualisation of the initial creature behaviour (you can change the speed of the animation to 'slow',
# 'normal' or 'fast')
w.show_simulation(titleStr='Initial population', speed='normal')

for i in range(numGenerations):
    print("\nGeneration %d:" % (i+1))

    # Create a new population from the old one
    population = newPopulation(population)

    # Pass the new population to the world simulator
    w.setNextGeneration(population)

    # Run the simulation again to evaluate the next population
    w.evaluate(numTurns)

    # Show the visualisation of the final generation (you can change the speed of the animation to 'slow', 'normal' or
    # 'fast')
    if i==numGenerations-1:
        w.show_simulation(titleStr='Final population', speed='normal')

Welcome to AI--you've certainly put a great deal of effort on this!  (I took the liberty of adding the "game-ai" tag, because this constitutes a form of game.)  I especially appreciate the extensive commenting in your code.

Is it difficult to answer if you do not describe btter with are the rules of the world. In the provided code, important parts are not present, in particular agent behavior, energy evolution, ... .

I think there are two problems with your approach.
First, your genetic algorithm contains crossover, but no mutations at all. In a GA, crossover causes convergence, while mutation is the only "exploration" operation. This means your creatures are stuck with whatever genes were present in their small initial population, and, even with modest selection pressures, they will rapidly converge to all being identical to each other. A common way to add mutation is to assign a random value to each location in each child's genome with a small probability (say, 0.01 * 1/number_of_genes). Some researchers prefer higher values. I'm not sure it's been definitely shown which is better, but it likely depends on your problem.
Second, throwing away agents that died might not be the best selection mechanism. You might get more interesting behaviours if you tied reproduction to something else (e.g. eating a lot of food while you were alive). Right now, your fitness function is probably incentivizing agents to hide in a corner and not do anything, since this maximizes the chance they survive to the end of the simulation.
Hope this helps a bit.


text:
Is it a valid Deep Neural Network?
For a regression task, I have sequences of training data and if I define the layers of deep neural network to be:
Layers=[ sequenceInputLayer(featuredimension) reluLayer dropoutLayer(0.05) fullyConnectedLayer(numResponse) regressionLayer]
Is it a valid deep neural network? Or do I need to add LSTM layer too?

Yes, it is a very common practice to use some RNN when your input data is a sequence.
Besides, your network has some shape issue if your input data is 2D. You should, at least flatten your input data to a vector to be able to forward propagate to the dense layer, but instead of this use some kind of RNN.
To the best of my knowledge, that dropout value doesn't good. It seems too low.

Thank you for helping. My training data is 1D and if I predict data using the above layers my prediction is 90% accurate. However, if I add LSTM layer after sequenceinputLayer, my accuracy suffers big time and I get a same predicted value no matter what sequence input do I use to predict. Can you suggest why is that?

My Xtrain = 823x1 cell and each individual cell/sequence contains 9x1 double data. That is my features/predictors are 9 and there are total 823 observations. My Ytrain= 823x1 cell and It contains the response of each sequence.

So, do you have 823 training points, where the input shape is (9,) and the output shape is (1,)? I am pretty sure about the (1,) because you do regression.

Yes that is so.


text:
How to teach an AI to race optimally in a racing game?
I play a racing game called Need For Madness ( some gameplay: https://www.youtube.com/watch?v=NC5uFZ-t0A8 ). NFM is a racing game, where the player can choose different cars and race and crash the other cars, and you can play on different tracks too. The game has a fixed frame rate, so you can assume that the same sequence of button presses will always arrive at the exact same position, rotation, velocity, etc. of the car.
I want to make a bot which could race faster than I can. What would be the best way to go about doing this? Is this problem even suited for deep learning?
I was thinking I could train a neural network where the input would be the current world state (position of the player, position of the checkpoints you have to through and all the obstacles), and the output would be an array of booleans, one for each button. During a race, I could then keep forward propagating from the input to the booleans. However, I'm not so sure what I would do after the race is over. How do I back propagate after the race to make the NN be less likely to make bad moves?


text:
How to open up a rigid structure made of connected panels?
By open up I mean slightly open up so that a theoretical structure of panels with no width looks three-dimensional. The original structure being an ideal object where any number several panels can occupy the same region of space (plane).
To concretize what I mean by rigid structure of panels, let's take what's on my profile picture. I'm including here a larger version of that object:

An origami figure is folded from a square and, unlike this simple example in the image, it can be very convoluted, with layers upon layers.
Let's say that if I have an ideal, theoretical and flat model of an origami picture and by flat I mean the faces are on planes but not necessarily on a single plane. For example all of faces of the figure in the image would be in one plane, but there could be figures with more planes; think of animals with ears, flippers, etc.
I would like to open up those parts that hinge on a theoretical segment (relatively easy) or curve or make a triangle of the corners of those faces that have two adjacent faces with no connections, open up a set of several faces that allow such opening of which the image is a good example.
So far I have tried programming rules for different structures suchs as flaps, ends, wrap-arounds... However there are three no small problems. First, it's extremely challenging to take into account all the corner cases and possibilities. I suspect it sounds simpler that it really is, but I don't want to digress with explanations. Second, the code is not maintenable. It's difficult to put into words rules that have to be visualized. Third it's very difficult to unit test and debug.
I strongly suspect that there must be some Artificial Intelligence techniques for doing this. Would you be so kind as to point me in the right direction? Just in a general way, without needing to go much into detail.
Let me know if I should include more info or code.

Welcome to AI!  (I edited slightly, assuming "IA" was a typo... is this correct?)  Have you looked at Erik Demaine's work?  He's a major origami force, and wrote a nice paper on Algorithmic Combinatorial Game Theory.  You can find his published papers here.  This paper, Geometric Folding Algorithms: Linkages, Origami, Polyhedra  looks like it might apply.

thanks @DukeZhou, there is a lot of info to take in there and it seems to have a more theoretical and geometrical approach, but I thank you for the link and I will take a closer look as soon as I have some spare time


text:
Deep Learning Approaches for Color Enhancement Testing
I'm a student, and currently into image processing project and coding using OpenCV. Recently, I watched Sebastian Thrun from Udacity in TedTalks talked about AlphaGo and I'm totally interested in the idea. I have read this question too : Merged Neural Network in AlphaGo.
I was wondering if same approaches can be used in my project.
I'm going to perform color enhancement method for any natural images. And of course, color sampling is a tricky task now. It's a lot of work, I have to prepare condition for each key-color sampling given and also prepare & pick the best enhancement function for it. I'm able to do it already using OpenCV.
But I was wondering if I could load tons of sample pictures instead, have my system test them against each other, and figure out its own enhancement rules from all testing.
I'm not that familiar with Deep Learning, we don't even have deep learning course at my university, but I'm interested in the idea and ready to learn. I'm not even sure if this can be done or not, but I wonder what kind of approaches should I learn to achieve my goal ? Is Deep Learning --> Neural Network a good start ? In my case, to which method in Deep Learning should I go with ? Any reference / advice will be highly appreciated. Thanks.