RadialNeuron::RadialNeuron(const char *filename/*=GNUFile.txt*/,int dim/*=2*/)
{
gpipe = popen("gnuplot -persist","w");
if(!gpipe)
{
exit(-1);
}
dimension=dim;
for(int i=0;i<dim;++i)
C_N.push_back(1.0);
sigm=2;
ofile.open(this->gnufile.c_str());
if(!ofile.is_open())
throw std::string("Can't create/open GNU file");
std::fprintf(gpipe,"set xrange [0:16]\n");
std::fprintf(gpipe,"set yrange [0:16]\n");
if(dim==3)
std::fprintf(gpipe,"set zrange [0:16]\n");
std::ifstream infile(filename);
if(!infile.is_open())
throw std::string("Can't open InFile");
training(infile);
infile.close();
}
int main(int argc, char* argv[])
{
Exampler train;
int i, mode = 0;
double C = 1, verb = 10, tau = 0.0001;
// parse options
for(i=1;i<argc;i++)
{
if(argv[i][0] != '-') break;
++i;
switch(argv[i-1][1])
{
case 'c':
C = atof(argv[i]);
break;
case 't':
tau = atof(argv[i]);
break;
case 'm':
mode = atoi(argv[i]);
break;
case 'v':
verb = atof(argv[i]);
break;
default:
fprintf(stderr,"unknown option\n");
}
}
// determine filenames
if(i>=(argc - 1))
exit_with_help();
std::cout << "Loading Train Data " << std::endl;
train.libsvm_load_data(argv[i], false);
char* save_file = argv[i+1];
// CREATE
int step = (int) ((double) train.nb_ex / (100 / verb));
std::cout << "\n--> Building with C = "<< C << std::endl;
if (mode)
std::cout << " BATCH Learning" << std::endl;
else
std::cout << " ONLINE Learning" << std::endl;
Machine* svm = create_larank();
svm->C = C;
svm->tau = tau;
training(svm, train, step, mode);
save_model(svm, save_file);
delete svm;
return 0;
}
TrackFace::TrackFace(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::TrackFace)
{
/* Set File Source Variables */
fn_path="/Users/dgyHome/Documents/QT/TrackFace/";
fn_images=fn_path+"resources/train_image.in";
fn_haar=fn_path+"resources/haarcascade_frontalface_default.xml";
fn_features=fn_path+"resources/features.in";
fn_namedb=fn_path+"resources/namedb.in";
im_width=250;
im_height=250;
window_x=300;
window_y=300;
/* Open DataBase */
try
{
iofunctions.read_images(fn_images,fn_path,images,labels);
iofunctions.read_name(fn_namedb,names);
}
catch(cv::Exception & e)
{
cout << "Error" << endl;
exit(1);
}
/* Train/Load Features */
if (!labels.empty() && labels[labels.size()-1]!=0)
{
if (QDir(fn_features.c_str()).exists())
model->load(fn_features);
else training();
}
haar_cascade.load(fn_haar);
/* Load GUI */
ui->setupUi(this);
}
void experiment2(int argc)
{
int i,j;
neuralnet* net = newneuralnet(2,30,argc-1);
training(net);
for(j=0;j<2;j++)
{
printf("weights: ");
for(i=0;i<31;i++)
{
printf("%d, ",net->neurons[j].weights[i]);
}
printf("\n");
}
distortions(net);
testdigits(net);
}
std::string toJSonString() const {
jsoncons::json result;
jsoncons::json training( jsoncons::json::an_array );
for( size_t i=0; i<trainingResults.size(); ++i ) {
const Result& r = trainingResults[ i ];
jsoncons::json elem;
elem["remainingEvaluations"] = r.remainingEvaluations;
elem["remainingEvaluationsWhenBestReached"] = r.remainingEvaluationsWhenBestReached;
elem["bestValue"] = r.bestValue;
training.add( elem );
}
jsoncons::json testing( jsoncons::json::an_array );
for( size_t i=0; i<testingResults.size(); ++i ) {
const Result& r = testingResults[ i ];
jsoncons::json elem;
elem["remainingEvaluations"] = r.remainingEvaluations;
elem["remainingEvaluationsWhenBestReached"] = r.remainingEvaluationsWhenBestReached;
elem["bestValue"] = r.bestValue;
testing.add( elem );
}
result["competitorName"] = competitorName;
result["competitorLanguage"] = competitorLanguage;
result["problemClassName"] = problemClassName;
std::ostringstream ostc;
ostc << trainingCategory;
const std::string trainingCategoryStr( ostc.str() );
result["trainingCategory"] = trainingCategoryStr;
result["datetime"] = datetime;
result["trainingResults" ] = std::move( training );
result["trainingWallClockUsage"] = trainingWallClockUsage;
result["testingResults" ] = std::move( testing );
result["testingWallClockUsage"] = testingWallClockUsage;
std::ostringstream os;
os << pretty_print( result ) << std::endl;
return os.str();
}
void foo()
{
image *train_data = (image *)calloc(COUNT_TRAIN, sizeof(image));
uint8 *train_label = (uint8 *)calloc(COUNT_TRAIN, sizeof(uint8));
image *test_data = (image *)calloc(COUNT_TEST, sizeof(image));
uint8 *test_label = (uint8 *)calloc(COUNT_TEST, sizeof(uint8));
if (read_data(train_data, train_label, COUNT_TRAIN, FILE_TRAIN_IMAGE, FILE_TRAIN_LABEL))
{
printf("ERROR!!!\nDataset File Not Find!Please Copy Dataset to the Floder Included the exe\n");
free(train_data);
free(train_label);
system("pause");
}
if (read_data(test_data, test_label, COUNT_TEST, FILE_TEST_IMAGE, FILE_TEST_LABEL))
{
printf("ERROR!!!\nDataset File Not Find!Please Copy Dataset to the Floder Included the exe\n");
free(test_data);
free(test_label);
system("pause");
}
LeNet5 *lenet = (LeNet5 *)malloc(sizeof(LeNet5));
if (load(lenet, LENET_FILE))
Initial(lenet);
clock_t start = clock();
int batches[] = { 300 };
for (int i = 0; i < sizeof(batches) / sizeof(*batches);++i)
training(lenet, train_data, train_label, batches[i],COUNT_TRAIN);
int right = testing(lenet, test_data, test_label, COUNT_TEST);
printf("%d/%d\n", right, COUNT_TEST);
printf("Time:%u\n", (unsigned)(clock() - start));
//save(lenet, LENET_FILE);
free(lenet);
free(train_data);
free(train_label);
free(test_data);
free(test_label);
system("pause");
}
void TrackFace::on_training_clicked()
{
training();
}
