TEST(ML_ANN, ActivationFunction)
{
String folder = string(cvtest::TS::ptr()->get_data_path());
String original_path = folder + "waveform.data";
String dataname = folder + "waveform";
Ptr<TrainData> tdata = TrainData::loadFromCSV(original_path, 0);
ASSERT_FALSE(tdata.empty()) << "Could not find test data file : " << original_path;
RNG& rng = theRNG();
rng.state = 1027401484159173092;
tdata->setTrainTestSplit(500);
vector<int> activationType;
activationType.push_back(ml::ANN_MLP::IDENTITY);
activationType.push_back(ml::ANN_MLP::SIGMOID_SYM);
activationType.push_back(ml::ANN_MLP::GAUSSIAN);
activationType.push_back(ml::ANN_MLP::RELU);
activationType.push_back(ml::ANN_MLP::LEAKYRELU);
vector<String> activationName;
activationName.push_back("_identity");
activationName.push_back("_sigmoid_sym");
activationName.push_back("_gaussian");
activationName.push_back("_relu");
activationName.push_back("_leakyrelu");
for (size_t i = 0; i < activationType.size(); i++)
{
Ptr<ml::ANN_MLP> x = ml::ANN_MLP::create();
Mat_<int> layerSizes(1, 4);
layerSizes(0, 0) = tdata->getNVars();
layerSizes(0, 1) = 100;
layerSizes(0, 2) = 100;
layerSizes(0, 3) = tdata->getResponses().cols;
x->setLayerSizes(layerSizes);
x->setActivationFunction(activationType[i]);
x->setTrainMethod(ml::ANN_MLP::RPROP, 0.01, 0.1);
x->setTermCriteria(TermCriteria(TermCriteria::COUNT, 300, 0.01));
x->train(tdata, ml::ANN_MLP::NO_OUTPUT_SCALE);
ASSERT_TRUE(x->isTrained()) << "Could not train networks with " << activationName[i];
#ifdef GENERATE_TESTDATA
x->save(dataname + activationName[i] + ".yml");
#else
Ptr<ml::ANN_MLP> y = Algorithm::load<ANN_MLP>(dataname + activationName[i] + ".yml");
ASSERT_TRUE(y != NULL) << "Could not load " << dataname + activationName[i] + ".yml";
Mat testSamples = tdata->getTestSamples();
Mat rx, ry, dst;
x->predict(testSamples, rx);
y->predict(testSamples, ry);
double n = cvtest::norm(rx, ry, NORM_INF);
EXPECT_LT(n,FLT_EPSILON) << "Predict are not equal for " << dataname + activationName[i] + ".yml and " << activationName[i];
#endif
}
}
std::string TrainProcessor::processInput(const std::string &input) {
cv::Mat samples, categories;
if (!fillSamples(input, samples, categories)) {
return "Unable to load samples from file";
}
const int inputSize = myCvPCA.eigenvalues.rows;
const int outputSize = myClassesList.length();
cv::Mat inputs;
myCvPCA.project(samples, inputs);
cv::Mat outputs(samples.rows, outputSize, CV_32FC1);
outputs = 0.0f;
for (int i = 0; i < categories.rows; ++i) {
char cat = categories.at<unsigned char>(i, 0);
int index = (int) myClassesList.find(cat);
outputs.at<float>(i, index) = 1.0f;
}
int layers = (myLayersCount > 0) ? myLayersCount : std::max(3, (int)(inputSize * myLayersScale));
std::cout << std::endl;
std::cout << "Layers number = " << layers << std::endl;
cv::Mat layerSizes(1, layers, CV_32SC1);
--layers;
std::cout << "Layer sizes: " << inputSize;
layerSizes.at<int>(0, 0) = inputSize;
for (int i = 1; i < layers; ++i) {
const float scale = myLayersSizeScale + (1.0f - myLayersSizeScale) * (i-1) / (layers-1);
const int sz = (int)(scale * (inputSize + (outputSize - inputSize) * i / layers));
std::cout << " " << sz;
layerSizes.at<int>(0, i) = sz;
}
std::cout << " " << outputSize << std::endl;
layerSizes.at<int>(0, layers) = outputSize;
std::cout << std::endl;
double timer = (double)cv::getTickCount();
myCvMLP.create(layerSizes, CvANN_MLP::SIGMOID_SYM, 1.0, 1.0);
myCvMLP.train(inputs, outputs, cv::Mat(), cv::Mat(), CvANN_MLP_TrainParams(), 0);
timer = (double)cv::getTickCount() - timer;
std::cout << "Training time = " << (timer / cv::getTickFrequency()) << " s" << std::endl;
std::cout << std::endl;
return "";
}
bool ImageClassifierANN::train(const Mat& trainingSamples32f, const Mat& trainingLabels32s) {
Mat layerSizes(1, 3, CV_32SC1);
layerSizes.at<int>(0) = trainingSamples32f.cols;
layerSizes.at<int>(1) = 20;
layerSizes.at<int>(2) = 1;
((Ptr<NeuralNet_MLP>)_classifier)->create(layerSizes);
Mat trainingLabels32f;
trainingLabels32s.convertTo(trainingLabels32f, CV_32FC1);
Mat sampleWeights = Mat::ones(trainingSamples32f.rows, 1, CV_32FC1);
return (((Ptr<NeuralNet_MLP>)_classifier)->train(trainingSamples32f, trainingLabels32f, sampleWeights) > 0 ? true : false);
}
void MLPDialog::on_buttonBox_accepted()
{
cv::ANN_MLP_TrainParams params = GetMLPParam();
cv::NeuralNet_MLP classifier;
int layers = ui->spinBoxLayers->value();
int eachLayerCount = ui->spinBoxEachLayerCounts->value();
cv::Mat samples;
cv::Mat response;
QSettings setting("config.ini",QSettings::IniFormat);
setting.beginGroup("Classifier");
QString mlpFile = setting.value("MLPClassifier").toString();
setting.endGroup();
setting.beginGroup("TrainDataConfig");
for (int i=0;i<ClassCount;++i)
{
QStringList stringList=setting.value(QString("Class")+QString::number(i)+"_Files").toStringList();
QString configPath = setting.value(QString("Class")+QString::number(i)+"_Config").toString();
std::vector<cv::Mat> some_samples= SignRecognitionToolkit::GetTrainImageCrops(stringList,configPath);
for (std::vector<cv::Mat>::iterator iter = some_samples.begin();iter!=some_samples.end();++iter)
{
cv::Mat feature = SignRecognitionToolkit::GetCropFeature(*iter,SignRecognitionToolkit::PAPER_63).clone();
samples.push_back(feature);
}
cv::Mat res(some_samples.size(),ClassCount,CV_32FC1);
for (int k=0;k<some_samples.size();++k)
{
float *p = res.ptr<float>(k);
for (int m=0;m<ClassCount;++m)
{
p[m] = m==i?1:0;
}
}
response.push_back(res);
}
setting.endGroup();
std::vector<int> layersize;
if (use_pca && pca_count<=63)
{
pca = cv::PCA(samples,cv::Mat(),CV_PCA_DATA_AS_ROW,pca_count);
samples = pca.project(samples);
std::cout<<"pca:"<<pca_count<<std::endl;
layersize.push_back(pca_count);
}
else
layersize.push_back(63);
layersize.insert(layersize.end(),layers,eachLayerCount);
layersize.push_back(ClassCount);
cv::Mat layerSizes(1,layersize.size(),CV_32SC1);
int *pMat = layerSizes.ptr<int>(0);
std::copy(layersize.begin(),layersize.end(),pMat);
std::cout<<layerSizes<<std::endl;
classifier.create(layerSizes,ui->comboBoxActivationFunction->currentIndex());
classifier.train(samples,response,cv::Mat(),cv::Mat(),params);
classifier.save(mlpFile.toStdString().c_str(),"mlp");
QMessageBox::information(this,tr("Completed!"),tr("Completed mlp training!"));
}
