https://www.microfocus.com/documentation/idol/IDOL_12_0/MediaServer/Guides/html/English/Content/Training/ImageClass_ImageGuide.htm

Classification is always better when more data is available, as a general rule. With more data points, the training tends to learn different variations to classify but it can also lead to increased time complexity. However, there is no set mechanism to identify how many points will be better for training a particular algorithm.

In this case, you can do a little upsampling or downsampling your data (or a particular class) if needed, to identify whether training improves in either situation (I am assuming you have a numerical dataset). But resampling too much data can also be harmful to training since it can bias the results towards sampled data.

Dear,

You can start training a model with only 50 sample of data points. Although it is recommended to take the bigger datasets for the model to complete understand your problem scenario.

Here is article of scikit-learn you can read it for more clear understanding.

https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html

In this map it is given how to choose a machine learning algorithm.

Hope you find this useful.

Thanks for sharing your question.

All the best.

Stay safe. Stay healthy.

Hi,

As a general rule, the more data the better. But there is no exact number of data points that you have to attain. Also, when data collection is constrained, you can use oversampling techniques. Also it depends on the number of features (system parameters in your case) that you plan to use. If you have more features than data points it will not be effective.

Also it seems that when you counted the data samples that you gathered you forgot that you have to keep data for testing purposes. If we use the general 80%/20% train-test split you will have 32/8 data points.

So my advice is to train a baseline model while keeping in mind the train-test split also you can try cross-validation (example using scikit learn) [https://scikit-learn.org/stable/modules/cross_validation.html] then you can analyze the performance.

I hope this helps.

The more data points you have, the more you are good to go. But please keep in mind, the quality of your data is more important than the quantity.

It depends on the complexity of the model, let me put it in a simpler context:

1. suppose we want to fit a linear model, it requires at least two datapoints. If we increase the complexity of the fitting equations e.g., quadratic, cubic, and higher-order polynomials, the requirements of the data points will increase accordingly.

2. Similarly, if we add more and more equations to be satisfied simultaneously, more data are needed.

For ML algorithms, this is insufficient data. "How many" is hard to describe. There is no specific guideline.

We are trying to make the machine or algorithms compute like us. The more data points we feed to them, the results are expected to be better.

While using SVM, the major issue tuning the kernel and kernel parameters. You need to come up with the best possible combination to get a good result.

There is no such restriction. Training and test data is based on the amount of data at hand as well as the choice of modelling: Parametric/Non-Parametric. The parametric models need 10 to 20% data for training and the remaining for testing, whilst in nonparametric 50 to 70% for training and the remaining for testing purposes.

two points

the answer to your question is "two points".

Yes, 120 points are justifiable for the classification, especially if your research requires it.

The only right answer to your question is Dr. Lutsenko's excellent answer: two points. Some further comments might be useful, though.

In real life, the problem is not "How many points should I have?" but "Given the data that I have, what classifier complexity can I afford for building a model that can generalize correctly to data that I do not have?". Generally, in real life, the data is there, and you are asked to make the best use of it for the task at hand. Here it seems that the task is three-class classification from 120 points. One very important piece of information is missing: the number of features.

You must first set apart at least 20% of the data for test purposes. This leaves 96 examples for designing the classifier, hence 32 examples per class if the classes are balanced.

For good generalization, the critical quantity is the ratio of the number examples to the complexity of the model. As a rough approximation, the complexity of the model can be estimated as the number of parameters that are adjusted during training. Thus, the critical quantity that must be considered here is the ratio of the number of examples to the number of parameters of the model. As a rule of thumb, it should be at least equal to 10 to obtain good generalization performances, but this is just an indicator. So if you had to design a 2-class classifier, 96 examples would limit the number of features to about 10. A 3-class classification problem can be solved by designing 3 two-class classifiers; each of them would be designed from 64 examples, so that the maximum number of features is around 6.

Thus, as a first approach, the available 120 points may be enough to build linear classifiers with good generalization if the number of features is on the order of 6. This is not by no means a sufficient condition, of course, because linear boundaries may no be complex enough for separating the examples with satisfactory accuracy. If the number of features is smaller than 6, you may afford to design nonlinear classifiers that will provide nonlinear boundaries between the classes.

If you use SVMs, the analysis is trickier because the number of parameters of the model is determined during training, so that you have to train the model and then check that the number of examples is at least 10 times as large than the number of support vectors found by the training algorithm. Plus, if you use a nonlinear kernel and soft margins, you must find, by cross-validation, the optimal hyperparameters of the kernel and the value of the regularization constant.