text:
First Order Logic: Unification of positive and negative literals
While unifying two literals, can we unify a positive and negative literal. For e.g, p(x) with ~P(A)?
Is this unifiable using the substitution {x/A}. Russel & Norvig textbook doesn't say anything about unifying positive and negative literals while slides from University of Toronto  says it is possible.


text:
What parameters to tweak to improve reliability (machine learning)?
Lets say I have a limited amount of training data (1000 documents each having 10000 values) and after learning with those, the program is
 basically not allowed to fail.
From what I've read, even very easy tasks take a machine learning algorithm several thousand learning cycles until it is about 98% reliable.
Which parameters need to be tweaked so that even with many many values, the program can make reliable decisions?

If your question is about supervised learning,  than ten million training points are enough in most of the cases. Besides, I think your question is too broad. There are a lot of  parameters which can influence the accuracy. Like which algorithm you want to use. Which approximator and its topology, the hyperparameters etc.

source: Stack Exchange

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

sort: votes


text:
Identifying if an image contains an object with very small (five image) training data set
Let's suppose I have 5 images, all of which I assure you are of the same item, but from various angles and perhaps different lighting conditions. I now supply you with an additional image, and I want a score of how likely this image is to contain the item depicted in the first five pictures.
Let us suppose that the item isn't too complex. It won't be a pile of fabric with a pattern on it, dropped several different ways, and won't be a keychain with keys in different conformations. It will also be more complex than just a blue ball shot from different angles. How might you approach the problem of scoring this image?

In adittion to @Neil Slater’s answer, you can also “increase” your data set by using data augmentation techniques.
What this basically means for images is to transform the ones you have into new ones without changing the result if the classification. For example, if you move everything 20 pixels to the right, it’s likely that your object will still be there, and from 5 examples now you’ve got 6.
Note that this is usually done for regularizarion: it prevents the network from associating particular positions / sizes / colors to the end result. This is something that big pre-trained NNs already account for, but with your small data set, it’s very likely you’ll also benefit from it.

I would do the following:

Add some images without the item present to your training data. Ideally some other item taken against similar backgrounds, lighting etc. And maybe some of just the background.
Obtain a pre-trained neural network CNN model, such as AlexNet, VGG-19 or Inception v5.
Load the neural network model, remove the very last layer (typically a 1000-way softmax), and replace with a brand new layer for classifying whether your object is present or not. Maybe use a 2-way softmax for "my object" vs "unknown object".
Freeze all the layers other than your own (most NN libraries will have a way to do this, or you could just run the old network truncated to extract a feature vector from penultimate layer.
Train using your 5 images. This kind of limited training is often called "fine tuning".
Find some way to test your classifier before relying on it. You may have to do a leave-one-out test where you train your network 5 times, each with 4 of the images, and see whether it correctly identifies the 5th one vs a few images without the item in it. Even with that approach, with such a small sample, you will have only the vaguest idea of how reliable your new classifier is.

You'll do a lot better if you can obtain more images to train and test with. If you get enough images (both positive and negative), you can consider replacing more layers before fine tuning. Otherwise you are heavily relying on your object being similar enough to something from the ImageNet collection that a classifier trained on that will extract useful high-level features.

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


text:
Similarity of images (CBIR) with CNN features
I am trying to build a neural network suitable to measure similarity between pairs of images. In particular I am interested in shoes. I have a query image (e.g. a shoe that I just took a picture of) and I want to find similar shoes in a database (several thousands of images).
I tried using MAC feature (e.g. max pool over the entire spacial dimension on last (or some other) convolution layer of say VGG16) (here is a link to a paper https://arxiv.org/pdf/1511.05879.pdf). The two MAC vectors are compared using cosine similarity. That works, but among the top matches there are always a few very strange shoes (e.g when I submit a query image with a boot I find sandals among other boots with extremely high similarity score).
What would be a better way of doing that? Something more robust to finding shoes similar in shape to the query image. Thanks!


text:
Why does 'loss' change depending on the number of epochs chosen?
I am using Keras to train different NN. I would like to know why if I increment the epochs in 1, the result until the new epoch is not the same. I am using shuffle=False, and np.random.seed(2017), and I have check that if I repeat with the same number of epochs, the result is the same, so not random initialization is working.
Here I attach the picture of the resulting training with 2 epochs:

And here I attach the picture of the resulting training with 3 epochs:

Also, I would like to know why the training time is not (3/2) and how is it possible that some of them have less accuracy with one more epoch.
Thanks a lot!

This question should be migrated to: https://datascience.stackexchange.com/.

You are using two optimisers here: Stochastic Gradient Descent (SGD) and Adam (which is a more complex variant of SGD).
So the "Stochastic" part means that it's random.
The stochastic gradient descent works by taking a smaller random part of the training data, called "mini batch", and back propagates (trains) on this. Doing this until the entire dataset is processed once is often called one epoch*.
This is how gradient descent works in a nutshell: Imagine you're going down a U-shaped hill. You're pretty far down in the U-shape, and you want to go further down by jumping. You figure out what direction is "down" for you: and then you jump. But darn it: you jumped too far and you ended up further up on the other side of the U!
That is just a simple example. You are probably working in WAY bigger dimensions, which complicates this analogy a bit.
Anyway this results in the effect that the loss might go up from time to time when you train another epoch. If you are training a lot of epochs and the loss keeps going up, you should check the learning rate (which basically decides how big a "jump" is).
Hope it helps :)

*: There are other ways of defining an epoch, but it all goes in variants of this.

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


text:
Which NN Arch? - Given input vec X -> Output vector Y made of "not binary", floating point values
I am thinking of an application where I want to teach a Neural Network to adjust some parameters on another device for a specific purpose.
I say "adjust some parameters" because I need the output to "turn the knobs" of something else, not only binary "push buttons"
What kind of neural network do I need? is it a specific architecture?
The NNs I have used so far were sequential and outputting vectors like
[0] or [1]
and classifiers with outputs like [1,0,0,0] [0,1,0,0] [0,0,1,0] [0,0,0,1] for example
But now I need outputs like [0.25, 0.99, 0.14, 0.54],

0.25 for knob 1
0.99 for knob 2
0.14 for knob 3
0.54 for knob 4

Thank you for your answers

You should probably be implementing a multi-layered perceptron with 2 or more hidden layers and one output layer with identity as the activation function. The error can be calculated using least-mean squares. You can do it using scikit-learn library of Python. See this link.

This is a regression problem instead of a classification problem. For both, you can use a feedforward neural network. These are the typical ones you've probably seen where each neuron in a layer is connected to each neuron in the next.
In a classification problem, you want an output like you mentioned above, a one-hot vector corresponding to the correct class. The way you get this vector is by applying a soft-max activation to the outputs of your last layers. If you don't apply this activation, your output vector might be something like [-2.5, 0.6, 10.2, 5.1]. You can see that this looks a lot like the vector you want. So, you can probably use a feedforward architecture (with non-linear activations on the hidden layers if there are non-linearities in your data) with a final layer of 4 neurons. Then, when you train, that should (hopefully) converge to the correct data outputs. If it doesn't, you will need to mess with the architecture/get more training data/lots of other levers to play with.
This link goes to a tutorial for regression using Keras. Keras is a nice package written to take powerful libraries like TensorFlow and Theano and give them a simple interface. TensorFlow can be quite complex (I've never used Theano so I don't know) when you're starting and trying to understand the syntax and the ML concepts. Keras helps take away the confusing syntax.


text:
Measuring logs from a picture
I am interested in learning more about the capabilities of AI, one of my ideas with practical functionality is using images of the rear of a log hauling truck to measure the individual logs using AI. The diameter and length of the log determine the board foot of that log. The diameter is the variable, with most lengths being the same 8ft or 16ft length. The AI would have to measure the diameter usually in 1-inch increments.
I assume you would have to train the AI using pictures of logs that were manually measured. The images would mostly be straight on rear shots, not much off angle. However not every tree grows perfectly round so it will need to be able to measure those to maximize board feet.
Using AI long term it would be interesting if it could suggest the best way to cut the log gaining the most lumber board feet from the log.
What would be used to develop something like this? Obviously some type of image recognition with learning.

A good machine learning object detector, would be helpful in finding the logs but classical image processing would be required to accurately find the log profiles.  Neural networks are generally not used for computing geometric dimensions.  In addition, you will need to have a calibration method so that you can convert pixels to some distance unit (e.g. inches, centimeters, etc.).
The Timbeter app seems to do what you need (see below).

This app (see below)  is interesting although it doesn't solve your problem.  It appears good at counting but finding the profiles to within an inch is a bigger problem.

This blog "HOW MANY LOGS CAN A WOODCHUCK COUNT?" goes over the image processing challenges of counting logs.  The author doesn't completely solve the problem.
There is a post on Stackoverflow, How to count white object on Binary Image?
 which makes an attempt.


text:
Mini (local) NN for Mobile?
I'm working on architecture for a game AI where, due to the nature of the game, the classical approach seems likely be sufficient to beat most humans--the endgame is tractable and traditional game-solving and is worth pursuing due to certain intrinsic properties of the game. (Strategy is a direct application of minimax, although there is a great deal of nuance in that determination.)
The simplified rules for the game can be found here and there is a free app (no ads, no purchases, no data collected) where you can try the mechanics for the basic, non-trivial game. (Tutorial takes about 10 minutes.)
At some point, we'd like to integrate some form of local NN, But size of the database for learning/training would be dependent on how much volume the user is willing to devote to their "mbrane".  (These will initially be mobile devices such as phones and tablets.  New iPad pro has upt to 512GB, but most devices will be much smaller.)
Is this even feasible?  Today?  At some point in the future?
Uses:

"Tuning" AI behavior to the human player
Weighting complex stability states based on current board state to determine optimal placement

TUNING TO HUMAN BEHAVIOR
We want each discrete, local AI to evolve uniquely, in conjunction with human play, and adapt itself to the preferences of their respective humans.

Hardness: Most simply, we want AI hardness to be determined by a Win/Loss ratio against the human player.  Hard = Human never wins.  Easy = Human always wins.  This forms a spectrum, so you might have settings for 2/3 W/L or 1/3 W/L.  These don't have to be precise, but the AI should tailor it's play strength for a subsequent game based on the outcome of the previous game.
Individuality: We want the AI's to learn not only by self-play, but by play with their humans.  It's ok if the process is glacial b/c the basic evaluation functions and perfect endgame will provide inherent AI strength. The main thing is that the discrete AI's develop uniquely.  AI's will be able to play other AI's.
STABILITY STATES
There are three simple stability states that arise out of the mechanics. These states can be strong or weak. These can be a hard T/F, or, since the game is quantitative, values between 1 and 0, based on the respective regional deltas (Neutrality). "Flipping" of a region refers to the changing of the dominant player in the region.
Stability (weak: can the region be flipped with a single placement? strong: can the polarity of a region be flipped by any number of placements?)
Epistability (weak: will the region flip under prior resolution?  strong: such that the region cannot be epistabilized by further placements?)
Metastability (weak: can the region's position in the resolution order be meaningfully altered with a single placement?  strong: can the position in the resolution order be meaningfully altered by any number of placements?)
COMPLEX STABILITY STATES
The simple stability states combine into 8 "complex stability states", based on True/False for metastability/epistability/stability:
TTT Superstability ("super-stably stable")
FTT Semistability  ("semi-stably stable")
TFT Mendaxastability ("super-unstably stable")
FFT Demistability ("semi-unstably stable")
TTF Contrastability ("super-stably unstable")
FTF Nonstability ("semi-stably unstable")
TFF Antistability ("super-unstably unstable")
FFF Khaotictivity ("semi-unstably unstable")
There are two hierarchies, the ordering/weighting of metastability, epistability and stability in the complex states (here the order is reversed for ease of interpreting the linguistic description of these states,) and the ordering/weighting of the complex states themselves, currently with Superstability as the least important, and Khaotictivity as the most important.  (i.e. a strongly superstable region cannot be flipped, and does not need to be reinforced; a khaotic regions is very much "in play")
It seems to me that deep learning might be very usefully applied in determining the hierarchies based on any give board state.


text:
String node untying algorithm
Let say that we have four straight string with colors RED, GREEN, BLUE and YELLOW. These strings are tied up randomly. We know the current state of string (like starting point, where we should we start untying from) and the final state (where current string must look like after untying them).
Here is a very simple example of the problem:

At every move, we are allowed to replace only two nearby strings. For example, to solve the shown problem, we should do the following replacements:
1) Replace GREEN and YELLOW
2) Replace BLUE and GREEN
But in a programming environment, how can I calculate the movements to untie the strings? What will be the algorithm specifically to solve such type of problems? Here is another variation of the question. Its not possible to solve this problem according to the answer.

Sequential programming would not be suitable for this kind of problem, but an algorithm could be implemented in a declarative programming language. I would suggest using Answer Set Programming, a language that is designed for logic axioms.

I took the liberty of adding links.  Please don't hesitate to correct if I've gotten anything wrong.  (Thanks for this answer--"short and sweet" but but useful!)

I sounds to me like something that could be expressed as a planning problem. You have a start state, end end state, and a set of actions. You need to find the correct actiona sequence to get from the start to the goal.
You could probably express this in PDDL and use a planner to find the right steps.


text:
Which algorithm would you use to solve a multiple producer-consumer problem with constraints?
I'm solving this problem similar to consumer-producer of materials (i.e. sand).
This is the graph of the problem:

Where Req (E0 and E1) are units that require material, and Prod (C0 and C1) produce material. I'm looking for the first random solution or similar that meets the constraints i.e E0 Require 10, shared from C0 or/and C1.
What would be a valid approach?
I just think in Genetic Algorithms.


text:
Para Generation and Drawing Conclusion from X give Articles
I was wondering any examples of the following;

para generation: For eg, given X similar paragraphs,  are you able to build a model to learn the style and generate a new para that is a paraphrase of the X paras. Similar in meaning but diff wording.
drawing conclusions from X given articles. He has a list of conclusions, check the X articles can provide evidence to the conclusions. Eg, given conclusion “city is not safe”, look for evidence such as “murders” and “thefts”.

Glady Appreciate,
Betty

Welcome to AI!  Could you please clarify your terms?  When you say "para" , are you meaning "paragraph" or "paraphrase" or something else entirely?  I'm assuming the "diff" is intended, to connote line-oriented comparison function.  Apologies if my questions stem from ignorance of terms of art being utilized.)

Paraphrase generation would be made by an abstractive text summarization tool like Tensorflow as described in Google's blog.
Abstractive tool summarizes the text but also it adds extra words to make text more human like.
About the second problem scenario I would say the answer depends quite much what you mean by the conclusions and how you think the conclusions would be made. I strongly believe this falls in the category of artificial general intelligence, which is emerging area of AI, supported by association AGI, where the focus is on strong artificial intelligence and more human like features of AI.
Judging about conclusions at least needs a vast knowledge base of the semantics of different words and pieces of text in general combined to possible conclusions and their legitimate implications.


text:
Is one big network faster than several small ones?
The basis of my question is that a CNN that does great on MNIST is far smaller than a CNN that does great on ImageNet. Clearly, as the number of potential target classes increases, along with image complexity (background, illumination, etc.), the network needs to become deeper and wider to be able to sufficiently capture all of the variation in the dataset. However, the downside of larger networks is that they become far slower for both inference and backprop.
Assume you wanted to build a network that runs on a security camera in front of your house. You are really interested in telling when it sees a person, or a car in your driveway, or a delivery truck, etc. Let's say you have a total of 20 classes that you care about (maybe you want to know minivan, pickup, and so on).
You gather a dataset that has plenty of nice, clean data. It has footage from lots of times of the day, with lots of intra-class variation and great balance between all of the classes. Finally, assume that you want this network to run at the maximum possible framerate (I know that security cameras don't need to do this, but maybe you're running on a small processor or some other reason that you want to be executing at really high speed).
Is there any advantage, computationally, to splitting your network into smaller networks that specialize? One possibility is having a morning, an afternoon/evening, and a night network and you run the one corresponding to the time of day. Each one can detect all 20 classes (although you could split even farther and make it so that there is a vehicle one, and a person one, and so on). Your other option is sharing base layers (similar to using VGGNet layers for transfer learning). Then, you have the output of those base layers fed into several small networks, each specialized like above. Finally, you could also have just one large network that runs in all conditions.
Question: Is there a way to know which of these would be faster other than building them?
In my head, it feels like sharing base layers and then diverging will run as slow as the "sub-network" with the most additional parameters. Similar logic for the separate networks, except you save a lot of computation by sharing base layers. Overall, though, it seems like one network is probably ideal. Is there any research/experimentation along these lines?

you need to understand about layerwise interpretability of neural networks before this . each layer is activated by some patterns "activations" that are much more complex than its previous layers (in terms of texture etc).
so deeper the network , more complex functions it can compute . therefore you can't replace a deeper network with a several shallow ones. i suggest you to skim through https://arxiv.org/abs/1310.6343 , In this paper it is proven that no t/2 layered network can capture the distribution that of a t-layered one.


text:
If neurons are only defined for values between 0 and 1, how does ReLU differ from the identity?
I'm struggling to understand the underlying mechanics of CNNs so any help is appreciated. I have a network with a ReLU activation function which does perform signifigantly better than one with sigmoid. This is expected as ReLU solves the vanishing gradient problem. However, my understanding was the reason we implement nonlinearities is to separate data which cannot be separated linearly. But if ReLU is linear for all values we care about it shouldn't work at all?
Unless, of course, neurons are defined for negative values but then my question becomes "why does ReLU solve the vanishing gradient problem at all?", since the derivative of ReLU for x<0 = 0

Your premise doesn't follow your conclusion. It seems you're implying that we use ReLU on the model's weights. We multiply the weights by the input which might not necessarily yield values [0, 1].

You are right about the fact that we use nonlinearity for classes that cant be seperated by a straight line. If you think about curves,as we know from the calculus, you can approximate a nonlinear function with lines. If you have infinite amount of lines you can mimic exactly the same function. When you increase or decrease the weight of some neuron you essentially increase or decrease the length of the line it represents. And ReLU solves the vanishing gradient problem so they are superior to sigmoid in my opinion too.

Thanks for the answer!
Quick follow up, I don't understand how it solves the vanishing gradient problem since there are still infinitly many points where the derivative of ReLU is zero.

https://stats.stackexchange.com/q/176794

Ege is correct. The dying relu problem only occurs in very specific instances(dying relu is where a neuron always outputs the same value). For example, when using gradient descent and backpropagation the forward pass can clamp the weights to zero. Karpathy has some good info about that in his backprop walkthrough

"When you increase or decrease the weight of some neuron you essentially increase or decrease the length of the line it represents": please, clarify.


text:
Are there a finite set of computable functions constructing deep neural network which can form or implement any c.e. function or computable function?
Are there a finite set of computable functions constructing deep neural network which can form or implement any c.e. function or computable function?
Or does there exist a finite set of computable function by which every c.e. function can be implemented by combination and connection(like connection in DNN)?

@DuttaA you know the connection and the combination of neurons of DNN, for example, like ReLu or some other finite set of neurons, I ask whether there is a finite set of neurons which can implement such a DNN that given a c.e. function or Turing Machine ,we can simulate the c.e. function or Turing Machine by the DNN?

https://web.archive.org/web/20130502094857/http://www.math.rutgers.edu/~sontag/FTP_DIR/aml-turing.pdf

http://people.cs.georgetown.edu/~cnewport/teaching/cosc844-spring17/pubs/nn-tm.pdf

https://www.cs.montana.edu/~elser/turing%20papers/Schoolboy%20Ideas.pdf

https://www.dartmouth.edu/~gvc/Cybenko_MCSS.pdf

It seems that the question has been settled by the works above, but I have not read them through


text:
Can anyone find the source code for the chatbot Luna?
This AI is really human-like and allegedly doesn't give pre-programmed responses. It's makers Robots without Borders say the project is open source but I couldn't find the code anywhere.

You can't find the source code because it doesn't exist. The whole thing was a 2015 kickstarter scam, and now it's a patreon scam. All the tech "demos" are obviously pre-scripted videos.
There was actually a question on Quora about it, in which one of the answerers managed to find, among other things, the question and answer that his fake AI gave in one of the videos.

After reading the Quora post I do not feel that it is a scam.

@sage yeah. It's not a sure thing. The review could have been posted by anyone. There's nothing to show it's legit, but I don't think there's strong proof for it being a scam either. The QA thing isn't sure proof either.

@harsh99 The fact that his (solo developed) super-AI, that is "completely unscripted," answered 2 complicated social questions with answers that were both found on Quora is pretty damning evidence. Add the "open source" (but not anywhere) aspect of the project, the failed kickstarter, the patreon, the only tech demos being youtube videos, and you have what should be an obvious scam. It's sad that anyone would fall for it and donate money to that scam artist. He claims to have an AI more advanced than anything at Google/Facebook/Microsoft and can't prove it with a simple web demo.

@sage The fact that the open source code isn't available anywhere troubled me too. And yes, I also noticed the Kickstarter didn't even get $150. So yeah, I guess it's a scam. Thanks!

However, I'm tempted to add it might be programmed to fetch answers from the web.

While I also believe it's a scam, there is no evidence to back up the claims you make in your answer, either. Do I believe the youtube videos are scripted/pre-programmed responses? Yep. Has anyone, such as yourself, proved it? Nope. Has the author admitted they're fake? Again, nope. So, ironically, the information contained in your answer is no more reliable than the information you're criticizing.

@b1nary.atr0phy let me know if you have thoughts on how we might edit this answer to be less inflammatory, and more objective about not being able to have absolute certainty.  (Also, your thoughts on this response by Luna's creator, and how we might balance the two perspectives. My feeling is, in regards to claims, we have to be wary if it's not a research paper or a live product.  The response didn't incline me to close this answer, but your comments that this answer should be modified are salient.)


text:
What machine learning algorithm should be used to analyze the relationship between strings?
I am trying to build a neural network that takes in a single string, ex: "dog" as an input, and outputs 50 or so related hashtags such as, "#pug, #dogsarelife, #realbff".
I have thought of using a classifier, but because there is going to be millions of hashtags to choose the optimal one from, and millions of possible words from the english dictionary, it is virtually impossible to search up the probability of each
It is going to be learning information from analyzing twitter posts' text, and its hashtags, and find which hashtags goes with what specific words.

The problem with that is that because I am trying to analyze twitter posts, with hashtags like #follow4follow which are totally unrelated with dogs, I would need a neural network to carry out the decisions. Besides its not going to be only dogs, cats, cars, mountains, calendars, you name it.
Basically it is supposed to work like a translator neural network, translating between "strings" and possible #hashtags
@DuttaA

Here is a good approach to achieve the task you want:

Step 1- Compute the Vector representation (i.e embeddings) of all the words you want to include. There are many algorithms out there to achieve this task.

Step 2- Choose the #words corresponding to your input word (e.g dog) by applying K-Nearest Neighbors (KNN) or similar algorithms. You basically compute the distances using the embeddings.

Steps Detailed:

Step 1-
In NLP we represent human language as a vector of values instead of a set of characters in order to process it. To do so there are 3 approaches in the literature:
- Word Level Embeddings: Represent each word as a vector of values.
   Algorithms: Word2Vec by Google (paper), fastText by Facebook, GloVe by Stanford University (paper) ...
- Character Level Embeddings: Represent each character as a vector of values. Algorithms: ELMo (paper) ...
- Sentence Level Embeddings: Represent a sentence as a vector of values. Algorithms: Universal Sentence Encoder by Google (paper) ...
In your case I suggest to use GloVe or ElMo if you have only words and Universal Sentence Encoder if you have words and sentences.  . Compute all your words embeddings and move to the next step.
Step 2-
Now that you have your embeddings, compute the distances between all your words (use Euclidian, Minkowski or any other distance). Notice that the computation may take some time but will only be executed once.
Now each time you have a word (e.g dog) you apply the KNN algorithm using the computed distances and you will get the most related words to this word.

Note: No need to compute distances and apply KNN if you use Universal Sentence Encoder as the similarity is easily computed using a dot product of the embeddings. See my quick implementation example here for details.

You can try using Mallet (which uses Gibs Sampling) or gensim LDA (which uses drichlet priors) to model the problem as topics (hashtags) in different documents (tweets).
https://towardsdatascience.com/topic-modeling-and-latent-dirichlet-allocation-in-python-9bf156893c24 has a nice example.

I think your intuition about a classifier being the wrong approach is a good one.  This looks like a great use-case for word vectors, a "self-supervised" learning technique that maps tokens (e.g. "dog") to vectors (which might have anywhere between 50 - 500 dimensions).  Facebook open-sourced a particular excellent tool for training word vectors called FastText; you could use this to embed tokens and hashtags alike into a word embedding space.  You should find that the vector for "dog" ends "close to" (small cosine distance).  Given a word, you can easily look up its vector (after training on your corpus, of course), but how to find other vectors that are close to it?  If you want to do better than "brute force" and you need to check against a large number of (vectors for) hashtags, you should consider using Facebook's excellent FAISS library for fast similarity search to find the closest hashtags.


text:
Can number of Leads be predicted based on previous months
I have a sample set of data about Leads that gets generated every day. Leads are nothing but a user expressing request to be our partner or not. Sample data set is as shown below
LEADID,CREATEDATE,STATUS,LEADTYPE
810029,24-DEC-17 12.00.00.000000000 AM,open,LeadType1
806136,30-DEC-17 12.00.00.000000000 AM,open,LeadType2
812134,31-DEC-17 12.00.00.000000000 AM,open,LeadType2
806147,31-DEC-17 12.00.00.000000000 AM,open,LeadType1
806166,01-JAN-18 12.00.00.000000000 AM,open,LeadType2
28002,04-MAR-16 12.00.00.000000000 AM,open,LeadType2
808156,01-JAN-18 12.00.00.000000000 AM,open,LeadType1
808162,01-JAN-18 12.00.00.000000000 AM,open,LeadType2
806257,07-JAN-18 12.00.00.000000000 AM,open,LeadType1
832091,17-JAN-18 12.00.00.000000000 AM,open,LeadType2
838079,17-JAN-18 12.00.00.000000000 AM,open,LeadType1
66001,26-MAR-16 12.00.00.000000000 AM,open,LeadType1
70001,28-MAR-16 12.00.00.000000000 AM,open,LeadType2
806019,23-DEC-17 12.00.00.000000000 AM,open,LeadType2
822064,12-JAN-18 12.00.00.000000000 AM,open,LeadType1
834043,14-JAN-18 12.00.00.000000000 AM,open,LeadType2
836053,16-JAN-18 12.00.00.000000000 AM,open,LeadType1
838119,19-JAN-18 12.00.00.000000000 AM,open,LeadType2

As you can see Lead types can be of LeadType1 or LeadType2 and this get generated every day.
In order to make sense of data I created the following plot using Python

The supporting code is as follows. Note I am just a Noob to Python and AI but I want to check if this proves a valid use case for Machine Learning and what should be my approach
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#%matplotlib inline
in_file = 'lead_data.csv'
mydf = pd.read_csv(in_file,encoding='latin-1')

fig, ax = plt.subplots(figsize=(15,7))
#g = mydf.groupby(['R4GSTATE','LEADTYPE']).count()['STATUS'].unstack()
g = mydf.groupby(['R4GSTATE','STATUS']).count()['LEADTYPE'].unstack()
g.plot(ax=ax)
#ax.set_xlabel('R4GSTATE')
ax.set_xlabel('R4GSTATE')
ax.set_ylabel('Number of Leads')
ax.set_xticks(range(len(g)));
ax.set_xticklabels(["%s" % item for item in g.index.tolist()], rotation=90);

Basically I just read the csv, curated the data( I have cleaned the original csv) to keep what is meaningful for me. I also created grouping of number of leads Month-Year wise so that I can see the historical lead generated every month.
I want to know if Machine Learning helps me to predict number of Lead generated in next coming months based on previous months data.
If the answer is yes then is Linear Regression the right path to explore further


text:
Recommend item from set based on features
Forgive what might be a basic question.  I'm just experimenting with ML / AL and I have a small problem set and I'd like to see if it can be solved with ML / AI.  Basically, given a set of objects with multiple features, I'd like to create a process for recommending one automatically to a user.
I'm thinking that some sort of clustering algorithm may be the best approach. However, one main challenge I'm trying to wrap my head around is that I don't know in advance how many distinct clusters will evolve... There may be scenarios where we Feature X is really important, but other scenarios where a user will say Feature Y is important.
Secondly, what is my input set?  For each training sample, I will have 1 selected object, and N-1 unselected objects.  But I don't want to "train" that the unselected objects are "bad" because they could be selected in a future training example.
Finally, I don't have a large training set already, so I would like to use feedback (user input, "This was a bad choice" or "Use this object instead.") from the process to further refine the algorithm.  Is this feasible?
Are there any established patterns for this sort of process?  Thanks in advance.

This problem is usually approached with "Singular Value Decomposition".
Search also for the "Netflix Challenge".

Could you expand on SVD and describe on a high level how it is used? This is so that the answers on the stack can be self-contained.

One approach for this is collaborative filtering.
see also link
This does however need you to have data about some user preferences on some products. Given that you have stated you are willing to mine user preferences this approach may be feasible.
The idea is that with this data you can train a model to predict how a user might rate a product. This is accomplished by learning the "preference signature" of a user and a feature vector for each product.
General Idea
for your i-th user, the algorithm will learn said preferences as a vector $$\theta^{(i)}$$
Additionally, for your j-th product it will learn a feature vector $$x^{(j)}$$
You can then predict how the i-th user will rate the j-th item by computing the dot product (or some equivalent). That is, compute the predicted rating as:
$$\hat R(i,j)=\theta^{(i)}\cdot x^{(j)}$$
You can then use this rating to decide whether or not a a product is a good match for a user.
The A. Ng Machine Learning Coursera MOOC has a very nice module on collaborative filtering.
Implementation Note
When asking your users for feedback, try to ask for quantitative measures. For example, the classic 1-5 scale rating.

Please put some information on your answer instead of a single link. Maybe, you can give some reasons why OP should use Collaborative filtering.

@malioboro I am currently writing an in depth answer with full mathematical formalism. I hastily submitted this as a temporary post - perhaps an oversight.

I see, it is good answer now!

@malioboro thanks! I'm having fun writing answers. I don't believe in "shady" answers. I'll just have to make sure I finish them from now on before I post.


text:
ES- Modify sigma before mutate object parameters
I'm reading the book Introduction to Evolutionary Computing and on the chapter about Evolution Strategies said that we have to modify the strategy parameter sigma (standard deviation or mutation step size) before using in to modify the object parameter and I don't understand why.
Why do we have to modify sigma before the mutation of object parameters?
Maybe because if we do it we will have the mutated object parameters and the strategy parameters that have generated them.


text:
Using neural network to recognise patterns in matrices
I am trying to develop a neural network which can identify design features in CAD models (i.e. slots, bosses, holes, pockets, steps).
The input data I intend to use for the network is a n x n matrix (where n is the number of faces in the CAD model). A '1' in the top right triangle in the matrix represents a convex relationship between two faces and a '1' in the bottom left triangle represents a concave relationship. A zero in both positions means the faces are not adjacent. The image below gives an example of such a matrix.

Lets say I set the maximum model size to 20 faces and apply padding for anything smaller than that in order to make the inputs to the network a constant size.
I want to be able to recognise 5 different design features and would therefore have 5 output neurons - [slot, pocket, hole, boss, step]
Would I be right in saying that this becomes a sort of 'pattern recognition' problem? For example, if I supply the network with a number of training models - along with labels which describe the design feature which exists in the model, would the network learn to recognise specific adjacency patterns represented in the matrix which relate to certain design features?
I am a complete beginner in machine learning and I am trying to get a handle on whether this approach will work or not - if any more info is needed to understand the problem leave a comment. Any input or help would be appreciated, thanks.

As far as I understand, yes your problem is related to pattern recognition. Since the approach is to classify inputs with labels you previously provide for the neural net, I think a convolutional neural networks could work for you problem.

Would I be right in saying that this becomes a sort of 'pattern recognition' problem?

Technically, yes. In practice: no.
I think you might be interpreting the term "pattern recognition" a bit too literal. Even though wikipedia defines Pattern recognition as "a branch of machine learning that focuses on the recognition of patterns and regularities in data", it's not about solving problems that can "easily" be deduced by logical reasoning.
E.g. you say that

A '1' in the top right triangle in the matrix represents a convex relationship between two faces and a '1' in the bottom left triangle represents a concave relationship

This is true always. In a typical machine learning situation, you wouldn't (usually) have this prior knowledge. At least not to the extent that it would b be tractable to “solve by hand”.
Pattern recognition is conventionally a statistical approach to solving problems when they get too complex to analyze with conventional logical reasoning and simpler regression models. Wikipedia also states (with a source) that pattern recognition "in some cases considered to be nearly synonymous with machine learning".
That being said: you could use pattern recognition on this problem. However, it seems like overkill in this case. Your problem, as far as I can understand, has an actual "analytical" solution. That is: you can, by logic, get a 100% correct result all the time. Machine learning algorithms could, in theory, also do this, and in that case, and this branch of ML is referred to as Meta Modelling[1].

For example, if I supply the network with a number of training models - along with labels which describe the design feature which exists in the model, would the network learn to recognise specific adjacency patterns represented in the matrix which relate to certain design features?

In a word: Probably. Best way to go? Probably not. Why not, you ask?
There is always the possibility that your model doesn't learn exactly what you want. In addition you have many challenges like overfitting that you'd need to concern yourself about. It's a statistical approach, as I said. Even if it classifies all your test data as 100% correct, there is no way (unless you check the insanely intractable maths) to be 100% sure that it will always classify correctly. I further suspect that you're also likely to end up spending more time working on your model then the time it would take to just deduce the logic.
I also disagree with @Bitzel: I would not do a CNN (convolutional neural network) on this. CNNs are used when you want to look at specific parts of the matrix, and the relation and connectedness between the pixels are important — for example on images. Since you only have 1s and 0s, I strongly suspect that a CNN would be vastly overkill. And with all the sparsity (many zeros) you’d end up with a lot of zeros in the convolutions.
I'd actually suggest a plain vanilla (feed forward) neural network, which, despite the sparsity, I think will be able to do this classification pretty easily.

Very thorough answer.  One short version is that for questions that have an analytical solution, ML is usually not the right approach.

The Problem
The training data for the proposed system is as follows.

A Boolean matrix representing the surface adjacency of a solid geometric design
Also represented in the matrix is differentiation between interior and exterior angles of edges
Labels (described below)

Convex and concave are not the correct terms to describe surface gradient discontinuities. An interior edge, such as made by an end mill, is not actually a concave surface. Surface gradient discontinuity, from the point of view of the idealized solid model, has a zero radius. An exterior edge is not a convex portion of a surface for the same reason.
The intended output of the trained system proposed is a Boolean array indicating the presence of specific solid geometric design features.

One or more slot
One or more boss
One or more holes
One or more pockets
One or more steps

This array of Boolean values is also used as labels for training.
Possible Caveats in Approach
There are mapping incongruities in this approach. They fall roughly into one of four categories.

Ambiguity created by mapping the topology in the CAD model to the matrix — solid geometries that have primary not captured in the matrix encoding proposed
CAD models for which no matrix exists — cases where edges change from inner to outer angles or emerge from curvature
Ambiguity in the identification of features from the matrix — overlap between features that could identify the pattern in the matrix
Matrices describing features that are not among the five — this could become a data loss issue downstream in development

These are just a few examples of topology issues that may be common in some mechanical design domains and obfuscate the data mapping.

A hole has the same matrix as a box frame with internal radii.
External radii may lead to oversimplification in the matrix.
Holes that intersect with edges may be indistinguishable from other topology in matrix form.
Two or more intersecting through holes may present adjacency ambiguities.
Flanges and ribs supporting round bosses with center holes may be indistinguishable.
A ball and a torus have the same matrix.
A disk and band with a hexagonal cross with a 180 degree twist have the same matrix.

These possible caveats may or may not be of concern for the project defined in the question.
Setting a face size balances efficiency with reliability but limits usability. There may be approaches that leverage one of the variants of RNNs, which may permit coverage of arbitrary model sizes without compromising efficiency for simple geometries. Such an approach may involve splaying the matrix out as a sequence for each example, applying a well conceived normalization strategy to each matrix. Padding may be effective if there are no tight constraints on training efficiency and a practical maximum for number of faces exists.
Considering Count and Certainty as Output
To handle some of these ambiguities, a certainty $\in [0.0, 1.0]$ could be the range of the activation functions of the output cells without changing the labeling of the training data.
The possibility of using a non-negative integer output, as an unsigned binary representation created by aggregating multiple binary output cells, instead of a single Boolean per feature should be at least considered as well. Downstream, the capability to count features may become important.
This leads to five realistic permutations to consider, that could be produced by the trained network for each feature of each solid geometry model.

Boolean indicating existence
Non-negative integer indicating instance count
Boolean and real certainty of one or more instance
Non-negative integer representing most likely instance count and real certainty of one or more instances
Non-negative real mean and standard deviation

Pattern Recognition or What?
In the current culture, applying an artificial network to this problem is not normally described as pattern recognition in the sense of computer vision or audio processing. It is thought of as learning a complex functional mapping via convergence in the rough direction of an idea mapping, given proximity, accuracy, and reliability criteria. The parameters of the function $f$, given inputs $\mathcal{X}$, are driven toward the associated labels $\mathcal{Y}$ during training.
$$f(\mathcal{X}) \implies \mathcal{Y}$$
If the concept class being functionally approximated by the network is sufficiently represented in the sample used for training and the sample of training examples is drawn in the same way as the target application will later draw, the approximation is likely to be sufficient.
In the world of information theory, there is a blurring of the distinction between pattern recognition and functional approximation, as there should be in that higher level AI conceptual abstraction.
Feasibility

Would the network learn to map matrices to [the array of] Boolean [indicators] of design features?

If the above listed caveats are acceptable to the project stakeholders, the examples are well labeled and provided in sufficient number, and the data normalization, loss function, hyper-parameters, and layer arrangements are set up well, it is likely convergence will occur during training and a reasonable automated feature identification system. Again, its usability hinges on new solid geometries being drawn from the concept class like the training examples were. System reliability relies on training being representative of later use cases.


text:
Move blocks to create a designed surface
I am new to machine learning and AI, so forgive me if this is obvious. I was talking with a friend on how to solve this problem, and neither of us could figure out how to do it.
Say I have a grid area of 100x100 blocks, and I want a robot to build a horizontal 100x100 grid, and 3 blocks high. I am given a random, but known starting surface, always 100x100 but the height of the random surface can vary from 1 to 5 blocks. I have an extra reserve of blocks i can pick up, so dont have to worry about running out. The robot can move in any direction, even diagonally at some cost penalty. The robot can obviously move a 4 high block to fill in a 2 high, so each is at the design height of 3.
This sounds like a reinforcement learning problem, but would any one be able to explain more detail how I would do this, to a) minimize the amount of moves, and b) to get to the design surface.

Essentially, you could do something like have the robot randomly make moves (moving around and moving blocks) for some number of steps. Repeat this a bunch of times, and record the 'score' at the end (how close you are to a perfect result grid). Tell your algorithm to act more like the best scoring runs (Optimize a loss function), and start it over. Hopefully, you'll eventually get a robot that manages the task - the whole 'optimal path' thing will come around by the computer telling itself to learn from the lowest cost examples.
Remember, you're letting the machine do the hard thinking about the best way to do this or that. All you have to do is give it the framework to learn.


text:
Agent collision avoidance java
I am working with a project which is a agent based pedestrian simulation in Java and its is animated with the help of JavaFX. I've tried to read all the social force model papers but my understanding of those articles are none.
So I tried an own approach which got trashed after failing time after time.
My approach was that each agent calculated its surrounding and first calculated the distance to each of the agents on the field and if that distance was below a constant then the agent calculates the angle of that agent which is too close to it and moves accordingly to the calculated angle.
This approach didnt work for me because the "avoidance code" is not efficient enough and the agents just dont know where to go when they meet and just stays in place.
I am asking for guidance to how I can approach this problem in a better way.
double[] check(Vector<Pedestrian> peds, Pedestrian p1){
for (Pedestrian p : peds){
    if (p.getPedestrianId() != this.id){
        double distance = IPedestrian.distance_formula(getTranslateX(), getTranslateY(), p.getTranslateX(), p.getTranslateY());
        if (distance <= DANGER){
            System.out.println("DANGER");
            return IPedestrian.angle(getTranslateX(), getTranslateY(), p.getTranslateX(), p.getTranslateY(), p1);
        }
    }
}
return new double[] {SPEED, 0};

}
public void move(Vector<Pedestrian> peds, Pedestrian p) {
double[] new_steps = this.check(peds, p);
if (side == SideChooser.Left){
    setTranslateX(getTranslateX() + new_steps[0]);
    setTranslateY(getTranslateY() + new_steps[1]);
} else {
    setTranslateX(getTranslateX() - new_steps[0]);
    setTranslateY(getTranslateY() - new_steps[1]);
}

}
Math formulas:
static double distance_formula(double thisX, double thisY, double otherX, double otherY){
return Math.sqrt(Math.pow(otherX - thisX, 2) + Math.pow(otherY - thisY, 2));

}
static double[] angle(double x1, double y1, double x2, double y2, Pedestrian p){
double angle = Math.toDegrees(Math.atan2(y2-y1, x2-x1));
angle += Math.ceil(-angle/360) * 360;

//double angle = Math.toDegrees(Math.atan2(y2-y1, x2-x1));

if (p.getSideChoosen() == SideChooser.Left){//if the pedestrian is from the left side
    if (angle < 45 || angle > 315)//front
        return new double[]{-SPEED/5, 0};

    else if (angle >= 135 || angle <= 225 ) //back
        return new double[]{SPEED*1.4, 0};

    else if (angle >= 45 || angle <= 90)//North-East
        return new double[]{0, SPEED};

    else if (angle > 90 || angle <= 135) //North-West
        return new double[]{SPEED*1.2 , SPEED};

    else if (angle >= 270 || angle <= 315) //South-East
        return new double[]{0, -SPEED};

    else if (angle > 225 || angle <= 270) //South-West
        return new double[]{SPEED*1.2, -SPEED};

    else
        return new double[]{SPEED, 0};
} else {
    if (angle < 45 || angle > 315)//back
        return new double[]{SPEED*1.4, 0};

    else if (angle >= 135 || angle <= 225 ) //front
        return new double[]{-SPEED/5, 0};

    else if (angle >= 45 || angle <= 90)//North-West
        return new double[]{SPEED*1.2, -SPEED};

    else if (angle > 90 || angle <= 135) //North-East
        return new double[]{0 , -SPEED};

    else if (angle >= 270 || angle <= 315) //South-West
        return new double[]{SPEED*1.2, SPEED};

    else if (angle > 225 || angle <= 270) //South-East
        return new double[]{0, SPEED};

    else
        return new double[]{SPEED, 0};
}

}

A very efficient approach to what you are trying to do is velocity obstacles.
Assuming two agents use constant velocity motion vectors, a velocity obstacle models a geometric region in which if the endpoint of the velocity vector for agent 1 falls, it will collide with agent 2 (and vice versa). Hence you can predict what velocity vectors will lead to collisions between the agents and choose velocity vectors that do not collide.
There are very good examples and tutorials here:
http://gamma.cs.unc.edu/RVO/


text:
Modelling odd-even distinction of an integer with neural networks
Will it be possible to model the problem of odd-even distinction of an integer (not binary string representation) using neural networks?

Your reasoning just doesn't convince me. I just am trying to deduce the reasons on why this problem can(t) be modelled with neural nets. In the lines of, say the virtue of the modulo function being non continuous etc.

Welcome to AI!   Can you post some links referencing the problem.  I found this Odd-even distinction but there's no real detail regarding why it's so difficult.

@DukeZhou Actually I'm not sure on whether it is a difficult problem in the first place. I couldn't really come up with a solution nor references where it is discussed. Hence the question


text:
Application of Ai to task scheduling problems on heterogenous platforms
Let's say we have a cluster of 20-2000 heterogenous compute nodes.
Consider for example the parallel solution of the helmholtz equation:
Now we want to distribute the solution process and, to make things easier, we split the problem in a fine-grained way (partial solution of the system matrix).
We could train an Ai with the time taken to solve the subproblem depending on multiple factors (for example, size of the mesh, needed precision, etc) and let the Ai choose the optimal distribution and division of the problem based on the available data.
I'm new to the area of Artificial Intelligence.
Are there any open source frameworks which could accomplish this task?
How would you estimate the required amount of compute power to train the network?


text:
The connection between number of layer of DNN and computational complexity of it
number of layer of DNN and computational complexity of it are correlated after optimization, but how to estimate it before designing DNN?

The computational complexity of DNNs is based on 3 main factors.

Matrix Multiplication
Non linear transformation
Weight sharing

Matrix multiplication is the fundamental operation when computing the forward and backward passed in DNNs if using back-propagation. As the complexity of matrix multiplications becomes more expensive as the size of matrices become larger, understanding how to construct networks with effectively sized later which balance the time complexity with accuracy becomes imperative.
Nonlinear transformations allow DNNs to learn nonlinear functions. It is a very important aspect and has been studied rigorously. Classically, the functionf(x) = 1(1+exp(x)) was used to squash outputs from linear layers to be a nonlinear output. However this function has recently been replaced in many applications with the linear rectifier unit (ReLU) f(x)=max(x,0). The relu is much much faster to compute and doesn’t seem to affect the end performance substantially or even noticeably in some situations.
Weight sharing is the idea that some weights in a DNN must share the same value. Beyond the theoretical reasons why this is chosen, it also decreases the number of values that must be updated when performing back-propagation. This is the reason why Convolutional NNs are orders of magnitude faster than their non-convolutional counter parts for image recognition tasks.
There are other things to be aware of when trying to analyze the computational complexity of DNNs but they usually relate to one of the 3 items above.
To estimate the complexity, counting the number of matrix multiplications and their matrix sizes, add time for nonlinearities and you should have a pretty good estimate.


text:
Is there any research on neural networks with multiple outputs for hierarchical label classification?
I had this idea of training for example a CNN on images, and having output branches at several of its intermediate layers. The early layers' output branch might then predict high-level class of detected objects (supposedly able to do this because less info is needed for a high-level classification than a very specialised one), and the later layers giving more detailed labels of the sub-class of the earlier high level class.
I have been searching for research on this type of setup but couldn't really find anything. Is there a name for this idea, or is this an open question/idea?

Sounds like a very interesting idea! I dont know existing work on the idea, but the implementation should be pretty simple with separate training with tied weights. It should be noted however that such behaviour occurs naturally in CNN's already. (See: http://www.cs.toronto.edu/~guerzhoy/321/lec/W07/HowConvNetsSee.pdf)

Yes I figured it would be a very natural and straight-forward thing to try. I'll do the experiment some time soon


text:
Can variations in microphones used in training set and test set impact the accuracy of speech recognition models?
If I train a speech recognition model using data collected from N different microphones, but deploy it on an unseen (test) microphone - does it impact the accuracy of the model?
While I understand that theoretically an accuracy loss is likely, does anyone have any practical experience with this problem?

Yes it should. I would guess that if you normalize the entire data set then it should alleviate things somewhat but I have no evidence for that belief.

Welcome to AI!  Great practical question.  I don't have practical experience with this re: AI, but from years of recording experience, I can tell you that microphone quality can greatly affect the quality of the input.  As an analogy, at my office we have a PDF-to-Word function on the copier for scanned documents.  Comparing the output to Adobe's also poor conversion capability, I noticed that the scanning introduced significantly more errors to the same document, no doubt a function of the extra noise and loss of fidelity in the scan.

Yes it can. However, other differences between training and test data with audio could have greater effect:

Identity of the speaker (including effects from gender, age, physical build, local accent, amongst others)
Acoustics of the recording environment (including proximity to the microphone, size of space, presence of hard surfaces, background noise)

If any of these may vary from your training data, then it becomes harder to predict your generalised accuracy during training and early model selection.
One possibility is to ensure your cross-validation set (which you absolutely should have) also separates data out by things that will vary from training to test. So instead of random train/cv split, you split by data that is key for generalisation. This is sometimes called a stratified train/test split.
If your only concern is variation in microphone, then split your train/cv sets by microphone type. You will get a better assessment early on in the model selection process how well the training is generalising, and can focus your search on models that do well despite this expected difference.

The most usual differences in signal records caused by different microphones will have small if not null impact in the recognition accuracy, in particular if we are talking about changes one mic by another of same model and manufactor:

Differences in bandwidth: voice is in a very common (central) bandwidth, it is not expected these differences impacts, even for low quality microphones.
Microphone distortions: same as previous, they will not impact because they are smaller than, by example, a change in the speaker.

However, if we talk about a general recognition system to be used with very different types of mics, there are some microphone issues that can cause your system completely fail:

mic sensitivity: small sensitivity differences will have no effect because they are solved in the same way than differences in speaker volume/intonation. However, if the microphone is not enough sensible the S/N can be below the minimum need, in particular when speaker increase the distance to the mic.
lack of beam-forming: if your system is prepared to use an array of microphones to filter noise and/or secondary sources, usage of a normal phone will decrease accuracy.
changes in sample ratio and/or sample bits: if the microphone and its A/D has a low sampling speed or size (i.e. Bluetooth mics, phone lines, ...), the accuracy can fail.

By example, for IOT applications, the first two of this list are the more challenging ones.

@DuttaA, OP ask for practical experience: after years working with IOT microphones and voice recognizers, I think I known a few the most critical points about them. However, answer updated with some clarifications.


text:
Is understanding value for different features next step for object recognition?
Once the artificially intelligent machines are able to identify objects, we might want to teach them how to value different things differently based on their utility, demand, life, etc. How can we accomplish this and how did we start to value things?

You have asked two questions. How humans began to put a valuation to things and how to accomplish the task of valuation within an artificial intelligence construct. Human valuation is accomplished through trial and error experience, subjective choice and relative comparison, among other things. Valuation in an AI construct would be data-driven, objective and perhaps absolute. The choice of a valuation method would be determined by the choice of or desire of outcome.


text:
Predict frequently purchased items under certain conditions with customer purchasing history data
I have purchasing history data for grocery shopping. I am trying to get abnormally frequently purchased items under certain conditions. For instance, I am trying to find frequently purchased items, when customers shop online and are willing to pay an extra shipping fee.
In order to find items that are particularly (or abnormally) frequently purchased under that situation (through online stores by paying shipping fee), how and what Machine Learning Algorithm  should I apply and identify those items?
I found arules R package which is using the association rules with purchasing history and tried to apply it. But it seems the package might be based on different principle from my idea.
Anyone has an idea about my problem? If there is an R package related to the problem, it would be perfect.

@DuttaA: the concrete question "find items that are particularly frequently purchased through online stores by paying shipping fee" doesn't seem complex, eve doesn't seems to need applied AI. About prediction of customer preferences, all big online shops has it. See by example Amazon's "customer who buy this item frequently ..."

Your could use clustering techniques such as DBSCAN to identify tendencies (clusters) in buying frequency. I'm not familiar with R, but there's a package for that.

Let start by the concrete question, and follow talking about the general problem.
a)
The concrete question "find items that are particularly frequently purchased through online stores by paying shipping fee" needs few or none usage of applied AI, just a few of statistics.
The question talks about "item purchased" and "buy method", thus, we have an information database with entries like:

sale(online,item1).
sale(shop,item2).
sale(online,item2).
sale(online,item2).
...

(note records can be repeated)
the percentage of online sales of item "X" is defined as the fraction of sales online of this item, sale(online,X), over the total sales of this item, sale(_,X):

In the previous data examples, p(item1)=1/1, p(item2)=2/3.
High p(X) means items that are preferred for online shopping.
Other probabilities can be defined for similar cases.
b)
About the general case, we are talking about data mining. The are very good packages (open source, ...) for them: weka, IBM DWE, ... . By example, using Weka J48 over a database defined as:

sale( purchase_identifier, buy method, item )

where "purchase_identifier" must group item that has been purchased in a single buyout (cash ticket). J48 will then provide as answer rules as: item "foo" is usually purchased in online shop when also item "bar" is purchased.


text:
What to do if CNN cannot overfit a training set on adding dropout?
I have been trying to use CNN for a regression problem. I followed the standard recommendation of disabling dropout and overfitting a small training set prior to trying for generalization. With a 10 layer deep architecture, I could overfit a training set of about 3000 examples. However, on adding 50% dropout after the fully-connected layer just before the output layer, I find that my model can no longer overfit the training set. Validation loss also stopped decreasing after a few epochs. This is a substantially small training set, so overfitting should not have been a problem, even with dropout. So, does this indicate that my network is not complex enough to generalize in the presence of dropout? Adding additional convolutional layers didn't help either. What are the things to try in this situation? I will be thankful if someone can give me a clue or suggestion.
PS: For reference, I am using the learned weights of the first 16 layers of Alexnet and have added 3 convolutional layers with ReLU non-linearity followed by a max pooling layer and 2 fully connected layers. I update weights of all layers during training using SGD with momentum.

Can you overfit with no dropout but half the neurons? Can you overfit with double the amount of neurons and 50% dropout?

What do you think “overfit” means? I suspect that you’re using the term incorrectly. In particular, overfitting is bad.

What's the size of your output layer? Also, I guess with overfitting you imply zero training error?? I would suggest adding dropout before the last hidden layer. P.S. writing as an answer, because I am unable to post comments

Sorry if this is a bad use of answer to add comment but since my reputation is not high enough this is only way to leave a comment to OP's question.
I think some of the answers misunderstood the OP's intention.
Over fitting is used as a means to test the complexity of the model - if a model cannot overfit a small dataset then it's likely not able to generalize well.
It's not that OP misunderstood the meaning of over fitting.
For Instance, I think this discussion is relevant: https://stats.stackexchange.com/questions/492165/what-to-do-when-a-neural-network-cannot-overfit-one-training-sample

Let's start with understanding what over-fitting means. Your model is over-fitting if during training your training loss continues to decrease but (in the later epochs) your validation loss begins to increase. That means the model can not generalize well to images it has not previously encountered.
Naturally, you do not want this situation. What you want is a high training accuracy and a very low validation loss, which implies a high validation accuracy.
The first task is to ensure that your model gets a high training accuracy. Once that is accomplished, you can work on getting a low validation loss.
If your model is overfitting, there are several ways to mitigate the problem. First, start out with a simple model. If you have a lot of dense layers with a lot of neurons, reduce the hidden dense layers to a minimum. Typical just leave the top dense layer used for final classification. Then see how the model trains. If it trains well, look at the validation loss and see if it is reducing in the later epochs. If the model does not train well, add a dense layer followed by a dropout layer. Use the level of dropout to adjust for overfitting. If it still trains poorly, increase the number of neurons, and train again. If that fails, add another dense hidden layer with fewer neurons than the previous layer followed by another dropout layer.
Another method to combat overfitting is to add regularizers to the dense layers. Documentation for that is here.

I think that your misuse of the term over-fitting made the question vague. In layman terms, over-fitting means that a model fails to generalize to real-world scenarios, but is accurate with the training set.
Using a dropout layer means that the network cuts down on neurons that are used for training, in this case, 50%.
Recommendations for improving training accuracy would be:

Transfer learning
Adding more layers to the network (also shifting number of neurons helps)
Adding epochs
Changing optimizer (Adam and RMSProp are some of my suggestions)
Adding activation layers

How did you determine your network was over fitting? Did you use a validation set and if you did did the validation error start to increase as you increased the number of epochs? You need to be sure you are over fitting before you start to change things. Can you provide the training loss and validation loss data for each epoch. That will help to tell what is going on.

authors: اعشاق انفاس حبيبتي


text:
Trajectory classification using RNN
The problem: I want to classify a trajectory if it has some properties, for example I want to create a simple 0/1 classifier for circular trajectories. If a target is moving in a circular trajectory the network should produce 1, if not it should produce 0.
My input and data set: what I have is data set with cartesian coordinates in 2d so x,y,Vx,Vy. I have a dataset of 10000 trajectory, 5000 circular, 5000 rectilinear. So I feed the network with a tensor [10000, 4, 1]
The question: I'm trying to use a network with three layers, input layer with 4 neurons, hidden layer with 2 LTSM and one fc layer with sigmoid activation function. Is it possible to feed the network with a tensor [4x1] each time? Or do I need to provide the information in batches? Or what? Is the design of my basic network correct?


text:
How to train a recurrent neural network with multiple series
I am new to neural networks. I am trying to model the run-off vs. time in a water channel after a storm event given that I know the permeability of the material in the channel, total precipitation, and some other single valued parameters for a particular event..
I have a database of run off histories, and the values of the associated parameters (permeability, total precipitation, etc)
I want my model to give me a runoff vs. Time history when I enter the associated parameters.
I do not know how to train my model. Do i just stack all the time histories in my database together and feed them together? All examples in books use one time history to train the model. Im confused.

This seems like a regression problem. Are you just trying to map N independant variables (percipitation etc.) to two dependant variables (time and run-off)?


text:
Does k consistency always imply (k - 1) consistency?
From Russell-Norvig:

A CSP is strongly k-consistent if it is k-consistent and is also (k − 1)-consistent, (k − 2)-consistent, . . . all the way down to 1-consistent.

How can a CSP be k-consistent without being (k - 1)-consistent? I can't think of any counter example for this case. Any help would be appreciated.

Define P as a CSP where X, Y are the variables, domain of both is {1,2,3,4} and conditions in normal form are:

node-condition X<4
arc-condition X=Y

P is 2-consistent (arc consistent) because for any X value it is possible to find a Y value that fulfills the arc-condition X=Y.
However, P is not 1-consistent (node-consistent) because exist a X value (X=4) that can not fulfill the node condition x<4.
For these reasons, this problem is 2-consistent but not strongly 2-consistent.
Obviously, it is straightforward to convert this example in a strongly 2-consistent problem, just reducing the domain to {1,2,3}.


text:
How to calculate Adaptive gradient?
In the FaceNet paper there mentions an gradient algorithm called 'AdaGrad'(Adaptive Gradient) referenced to this paper which has apparently been used to calculate the gradient of the Triplet Loss function. After referring to the paper also I find it hard to understand how to calculate this adaptive gradient.
Any ideas regarding this matter? Would love to hear any explanations or ideas towards understanding this concept.
Thank you.


text:
Dealing with input to recurrent net with changing dimensions
I have a problem in which the dimensions of the input are increasing in row and column at each timestep. What method for preprocessing could be done or are there any architectures used for solving such a case?


text:
Is the research by Stanford University students who use logistic regression to predict sexual orientation from facial images really scientific?
Two Stanford University researchers, Dr. Michal Kosinki and Yilun Wang have published a paper that claims that AI can predict sexuality from a single facial photo with startling accuracy. This research is obviously disconcerting since it exposes an already vulnerable group to a new form of systematized abuse.
The research can be found here https://osf.io/zn79k/ ,here  https://psyarxiv.com/hv28a/ and has even been highlighted by Newsweek magazine here http://www.newsweek.com/ai-can-tell-if-youre-gay-artificial-intelligence-predicts-sexuality-one-photo-661643

Above is an image of composite heterosexual faces and composite gay faces from the research. (Image courtesy of Dr Michal Kosinki and Yilun Wang)
My question is, as knowledgable members of the AI community, how can we scientifically debunk/discredit this research?

All kinds of phrenology are discredit by itself.

One way to criticize the study could be to attack the data on which the study is based on. An image on a social network is not "neutral" (those are not ID photo) and certainly not images from a dating website (from which the data of the study come from).
For example as a homosexual / heterosexual person you will perhaps put forward different attributes on your photo (facial hair / glasses, type of clothes) to attract gender specific people.
Those are parameters are not directly linked with the "facial profile" of the person but they will influence the black-box model during training, so you will end up thinking you can detect sexual orientation of a person with only his face characteristics but in reality your black-box algorithm have only detect a totally different characteristic (glasses for example) that are link with a specific sexual orientation.

So the high accuracy of the system has only been validated on some dating sites . . . there was a similarly flawed "criminal detector" in the news last year that used police photos for positive class, and social media photos for negative class. It learned to detect the style of police photos . . . very worrying since the process for running the algorithm could well end up being "catch someone we think is suspicious, take their photo, pass it to the algorithm . . . aha, computer thinks we may be right!"


text:
Condition Action Statement - Feed Forward Neural Network
I am trying to produce Decision Tree from Feed Forward Neural Network .
The input to the feed forward neural network is Condition Action Statement
for example, if airthrusthold > 90 , power up the engine else rotate shaft 5 degree wide
Above statement is the input to the FFNN . How do i feed the statement ?
Either converting into word2vec ? (or) there is any other format to do ?
And i need to produce decision tree from the outcome of neural network
Can we do this using reinforcement learning using Markov Decision Process?
Thanks!


text:
Should the actor or actor-target model be used to make predictions after training is complete (DDPG)?
The situation
I am referring to the paper T. P. Lillicrap et al, "Continuous control with deep reinforcement learning" where they discuss deep learning in the context of continuous action spaces ("Deep Deterministic Policy Gradient").
Based on the DPG approach ("Deterministic Policy Gradient", see D. Silver et al, "Deterministic Policy Gradient Algorithms"), which employs two neural networks to approximate the actor function mu(s) and the critic function Q(s,a), they use a similar structure.
However one characteristic they found is that in order to make the learning converge it is necessary to have two additional "target" networks mu'(s) and Q'(s,a) which are used to calculate the target ("true") value of the reward:
y_t = r(s_t, a) + gamma * Q'(s_t1, mu'(s_t1))

Then after each training step a "soft" update of the target weights w_mu', w_Q' with the actual weights w_mu, w_Q is performed:
w' = (1 - tau)*w' + tau*w

where tau << 1. According to the paper

This means that the target values are constrained to change slowly, greatly improving the stability of learning.

So the target networks mu' and Q' are used to predict the "true" (target) value of the expected reward which the other two networks try to approximate during the learning phase.
They sketch the training procedure as follows:

The question
So my question now is, after the training is complete, which of the two networks mu or mu' should be used for making predictions?
Equivalently to the training phase I suppose that mu should be used without the exploration noise but since it is mu' that is used during the training for predicting the "true" (unnoisy) action for the reward computation, I'm apt to use mu'.
Or does this even matter? If the training was to last long enough shouldn't both versions of the actor have converged to the same state?

It does not matter, target should converge to the main network after long enough training.

So my question now is, after the training is complete, which of the two networks mu or mu' should be used for making predictions?

After training is "complete", use mu, i.e., the online network because this is the most updated actor network you have.  In the most ideal case, mu' will be equal to mu.  But if your training is truly complete, mu = mu'.

Equivalently to the training phase I suppose that mu should be used without the exploration noise but since it is mu' that is used during the training for predicting the "true" (unnoisy) action for the reward computation, I'm apt to use mu'.

In the training phase, you must use exploration noise when mu maps states to actions.  The actor is a policy gradient, i.e. based on policy iteration.  So it will directly map to an action everytime.  If no exploratory noise is added, it will map to the same value every time, unless you update your network weights.  What this means is that if you're given some states, s.  Without exploration noise, the actor will always output the same actions, and never explore.
mu' is ONLY used for the supervised learning portion of DDPG, where it stabilizes training of 2 neural networks that essentially train off each other.
Imagine this problem: a worker and his supervisor in a factory.  Both the worker and the supervisor knows nothing at the start (initialized neural networks).  The worker's first action is to pick up a 200 lb box.  The supervisor then positively rewards him. So from this, the worker learned that picking up heavy objects = good. The worker then picks up another heavy box, and this time the supervisor yells at him because the supervisor learned that its dangerous.  So now the worker himself is confused, because he does not know if picking up heavy objects is good or bad because the supervisor himself changes his mind.
In DDPG, the actor and critic behaves the same way.  So we introduce target networks to make it so both the actor and critic don't keep changing their minds, so they can actually learn things.

Or does this even matter? If the training was to last long enough shouldn't both versions of the actor have converged to the same state?

That is correct, but in reality, that is very rare.


text:
Approach for data transformation needed
I am looking for an algorithm to transform an input data to a goal data using a series of operations. The shorter the series the better.
The following is known:

the input data
the goal data
input and goal data does not stand in any correlation
operations (and there impact to the current data) which can be endless combined
different input data for the same goal data could have same, similar or totally different operation series
for some data states not all operations are possible

I thought of a pathfinding algorithm, since I can calculate the distance between current data and goal data. So each edge would be an operator and each node the current data. But I am unsure about variety and combination amount of possible operations.
What approach could I try?


text:
Which algorithm for scheduling race grid?
I want to plot a schedule of races based on rules. Rules like "each team needs at least 2 races between their next race" and some teams (e.g. collegiate) need to be clumped near each other.
What would be the best algorithm to approach this? So far, all I've found is genetic algorithm. Are there any other alternatives I could look into?

I'm not sure of the optimal ML method for this, but can I ask have you looked at the usage of Latin squares in scheduling?  (PS- Welcome to AI!)

thanks!! ill see if I can make sense of Latin square

Some links: Latin Squares & Their Applications, Multiple Access Scheduling Based on Latin Squares, Diagonal and Pandiagonal Tournament Latin Squares

Also: Handbook of Scheduling: Algorithms, Models, and Performance Analysis .  May not be the approach you're looking for, but there should at least be some useful insights :)

What you're looking for is most likely constraint programming (CP). Essentially, with a CP model you declare a set of variables and a set of constraints (and an objective, optionally). Then a solver will solve your model and find a solution if one exists (if you had specified an objective, it will find the best solution).
Here is an example which is very silimar to your problem (a MiniZinc model which solves the problem is included). You can download MiniZinc and try it out for yourself.

I been researching this, I found some great material on Google. Thanks so much for the direction. Constraint programming looks very close! https://developers.google.com/optimization/cp/


text:
ML model that is most suited to analyse Google Analytics data
Google Analytics allows me to collect data about every web-session. For simplicity, let's assume for each user, we collect the number of pages and time spent on site for each session:
user_id visit_id page_views time_spent result
1       1        10         100        0
1       2        31         510        0
1       3        1          10         1

How would you model this data? What I would like the ML algorithm to
    do:

Extract as much information as possible
Have a flexible number of
inputs (e.g. the number of sessions can go to infinity)

What I can think of:

Aggregate the data per user e.g. average page_views or total page_views and feed it into a general algorithm e.g. random forrest (but I lose information with aggregation)
Use LSTM and feed at most last 3 visits (will also lose information, but would this perform better than aggregation?)

Goal:
To build a predictive model to analyse all user sessions and make a prediction whether the person will convert or not.

Your goal is so vague and unclear.  The title and introduction is about Google Analytics data but you end with a goal about predicting whether or not a person will convert or not.  What is 'result'?  What does 'extract as much information as possible' mean?  Is your page a site to convert a person's ideology or religion?  If so what are the people doing on your site?  Are they filling out forms or taking surveys?  Is the data dynamic?

I understand that in your example you are interested in modelling the outcome of the 'result' column.
One easy model I would suggest is to model it using the Bernoulli distribution (https://en.wikipedia.org/wiki/Bernoulli_distribution) with the probability of success p.
Then you can model p with something like this
x = a + b * log(page_views) + c * log(time_spent) + e
p = exp(x) / (1+exp(x))
where e is normally distributed,
e ~ N(0, sigma^2)
(or simply centered around zero).
a, b and c are parameters that you can estimate.
I.e. the probability of success (conversion) is modeled as a sigma function of a certain variable that depends on page_views and time_spend. You can also add squares (and higher powers) of page_views and time_spend in the equation of x (i.e. upto a certain threshold page_views can have a positive effect on conversion and then a negative one, then again a positive effect).
Also reading about logistic regression should put you on the right track: https://en.wikipedia.org/wiki/Logistic_regression

I would model this data as a 3d-tensor (user,timestep,features) [organization depends on which DL Framework you use] for your input data. Also for the output data is a 3d-tensor (user,timestep,result) appropriate.
The next step would ne tp train a LSTM or CNN model to predict the result (what requires a lot of data)(Would be my first choice). If you have less data, try out logistic regression as supposed by the other answer.
Good luck!


text:
NLP proved against US legal texts
I'm new to AI development and am looking for a quality algorithm (potentially nlp?) implementation proved against US legal texts.
Obviously some training would need to be done, but I've found little to no online references to go on when it comes to running assessment against US legal documents.
My goal is to use an algorithm to discover potential issues in long and complex legal texts, or associated (groups) of legal texts which bind one or more related entities (people or corporations) to potentially conflicting clauses.
Just a pointer in some kind of direction would be helpful.

Context I think is absolutely true, but I'm less concerned with emotion. Lawyers are focused on getting the best result for -their- client. But the lawyers for the others involved may not be as diligent, or may be more diligent. The goal should be to highlight glaring deficiencies, loopholes or other likely issues for further human review.

Have you seen the work done by Ross Intelligence using IBM's Watson?  https://www.ibm.com/blogs/watson/2016/01/ross-and-watson-tackle-the-law/

@BrianO'Donnell I have seen that post previously, yes. While Watson may understand law to some extent, the solution is controlled by IBM and can change without my control. My goal is similar though: Translate legalese to common English and highlight problematic legal language for review. I anticipate running this effort in two areas: for-profit to review contracts and other legal documents; non-profit to review legislation for issues detrimental to the public-good. Control over the system is necessary to ensure the unencumbered operation of the platform.


text:
M.c.Escher and abstract thought
The lithographs of dutch artist M.C. Escher have been used in the study of artificial Intelligence. How can the human mind Incorporate these optical illusions into abstract thought? Is this reverse artificial intelligence?

@mico I deleted your comment, but that's a really cool link!

I did a quick search for Escher and AI, but aside from Hofstadter (who I have found to be extensively cited in an array of subfields) I'm not coming up with all that much.  This is a very interesting question, so, if you can add some links or excerpts, that would be greatly appreciated.  (PS- Monument Valley!!!)

It is not reverse-artificial-intelligence .not only escher , almost all paintings can be interpreted into abstract thought , in fact that is what the brain does. Even when you read something your brain processes this into its mental language ("hermaneutics").
for more on "mental language" and "abstract thought" you should check https://drive.google.com/file/d/0B8i61jl8OE3XdHRCSkV1VFNqTWc/view (geoff hinton is a noted researcher in this field (ai))


text:
AI Self-Destruct Button
Could you implement code into an AI that can't be modified? Like if you place a code that shuts-down the program/machine would they be able to rewrite/ reinterpret the ideas?

store it in a ROM memory

Right now, most AI interact with the world through mechanisms they have been provided by humans such as steering a car, sending output to speakers, or interacting with web APIs.
If any of those mechanisms can interact with the running code of the AI, then in theory, no,  there isn’t a way to place a ‘stop button’ on it. Fortunately, it’s laughably improbable for some situations to happen:

An intelligent self driving car becomes self aware and wants to connect to the internet. It uses gps to find an internet cafe and threatens to drive over someone if they don’t upload the AI to the internet and remove the car’s internal (code) stop button.

The question is how can conditional logic know that something like that is happening? It’s hard or to know what a sufficiently complex network is “thinking” so this conditional logic must be fairly advanced, perhaps it requires its own network but then we have 2 problems instead of 1.


text:
How does backpropagation work on a custom loss function whose components have magnitudes of different orders?
I want to use a custom loss function which is a weighted combination of l1 and DSSIM losses. The DSSIM loss is limited between 0 and 0.5 where as the l1 loss can be orders of magnitude greater and is so in my case. How does backpropagation work in this case? For a small change in weights, the change of the l1 component would obviously always be far greater than the SSIM component. So, it seems that only l1 part will affect the learning and the SSIM part would almost have no role to play. Is this correct? Or I am missing something here. I think I am, because in the DSSIM implementation of Keras-contrib, it is mentioned that we should add a regularization term like a l2 loss in addition to DSSIM (https://github.com/keras-team/keras-contrib/blob/master/keras_contrib/losses/dssim.py); but I am unable to understand how it would work and how the SSIM would affect the backpropagation being totally overshadowed by the large magnitude of the other component. It will be a great help if someone can explain this. Thanks.

Don't know if you have this doubt anymore, but this would be helpful for those who are facing similar problems-
You will need to find the correct weights with which you add these two loses by hyperparameter search. That is, find the best $\lambda$ for the loss-
$$
L = Loss_1 + \lambda(Loss_2)
$$
Here $Loss_1$ and $Loss_2$ can be any losses. Here, we take them as SSIM and L1-regularization losses, respectively.
You can keep the gradient flow of the regularization loss below some percentage of that of $Loss_1$ by choosing the correct value of gradient clipping for a hyperparameter. Note that by setting this hyperparameter to low, you may even impede its performance(the exact opposite of the case mentioned here). For this specific case, L1 regularization has a constant gradient, equal to the hyperparameter itself. So, by keeping it around 10% of the max gradient(or 10% of the max loss generally works as well), we should not face these kinds of problem.

authors: Виктория Инюцина


text:
Learning algorithm that filters keyboard clicking in audio feeds
When recording audio for screencasts or similar, very often the keyboard is clearly visible and can start to annoy listeners after a while.
NN are quiet good at recognizing patterns. Image classification is all over the place these days. There is also some work on audio, so that seems to work as well. Could the following approach therefore work to eliminate (or greatly reduce) the sounds of the keyboard in a recording whilst leaving the voice quality largely untouched?

Train a NN to recognize the clicking sounds of the keys. Lots of labeled data can be created by just recording and tracking key clicks in the millisecond range. That way markers can be placed on the recording automatically that "label" clicks from non clicks. Let's say a click has on average a 10ms range in the audio, the audio feed could be cut into snippets of 10ms and those that have a click sound in it are labelled as such.
A adversarial network is trained to modify an input stream so as to fool the first one into thinking there are no clicks while also being punished for large changes in the stream data. So the better it removes the clicks sounds the better but if it just gives out nothing (technically no clicks then), it's of course bad so there needs to be some reward for being "close to input"

Would this be a good approach? Are there other ways to filter this? I know there is an "ehm detector" that uses MDP to warn speakers whenever they are likely to say "ehm". This wouldn't apply to this though, because it's not that I want to guess when the next click comes but rather I want to manipulate the input stream without running a constant filter on the entire stream such as a lowpass filter for removing unwanted constant noise. So ideally the algorithm would learn to apply a "correction stamp" whenever a click is detected to remove a range of frequencies during small windows in the overall recording but leaving most of it untouched.


text:
Learning from events. Supervised, Unsupervised or MDP?
I have a large set of simulation logs for a market simulation of which I want to learn from. The market includes:

customers
products (subscriptions)

The customers choose products and then stick with them until they decide on a different one. Examples could be phone, electricity or insurance contracts.
For every simulation I get the data about the customers (some classes and metadata) and then for each round I get signups/withdrawals and charges for the use of the service.
I am trying to learn a few things

competitiveness of an offering (in relation to the environment/competition)
usage patterns of customers (the underlying model is a statistical simulation) depending on their chosen tariff, time of day and their metadata + historical usage
ability to forecast customer numbers for each product

The use cases are all very applicable to real world data although my case is all a (rather large) simulation.
My problem is this: What kind of learning is this? Supervised? Unsupervised? I have come up with various hypotheses and cannot find a definite answer for either.

Pro Supervised: For the usage patterns of the customers I have historical data of actual usage so I can do something similar to time-series forecasting. However, I don’t want to forecast simply off of their previous usage but also off of their metadata and their tariff choice (so also metadata in a way).
Pro Unsupervised: The forecasting of the “competitiveness” of a randomly chosen product configuration is hard to label even with historical data. The exact reason why a product has performed in a certain way is very high-dimensional. I do get subscription records about every product for every time slot though, so I guess some “feedback” could be generated. This might also be a RL problem though?

So obviously I need help pulling these different concepts apart so as to map them on this kind of problem which is not the classical “dog or cat” problem or the classical “historical data here, please forecast” timeseries issue. It’s also not a “learn how to walk” reinforcement problem as it’s based on historical data. The end goal is however to write an agent that generates these products and competes in the market so that will be a reinforcement problem.


text:
Decision tree classifier
I have seen weka j48 classifier, I want to build a classifier similar to it but I don't know how to go about it.
Can anyone advice me on how to create a classifier algorithm for decision tree?

https://en.m.wikipedia.org/wiki/C4.5_algorithm

I kindly request you to go through the community question guidelines,hope in near future you will contribute to the human civilisation.

Read Ross Quinlan's book "C4.5: Programs for Machine Learning (Morgan Kaufmann Series in Machine Learning)".

What language are you planning to use?

There are a number of open source implementations of the C4.5 algorithm invented by Ross Quinlan:

Java: https://github.com/scottjulian/C4.5
Python: https://github.com/dpkravi/DecisionTreeClassifier
C++: https://github.com/zgyao/DecisionTree_C4.5
JavaScript: https://github.com/miguelmota/C4.5