int main(int n_args, char** args) { double intersection = 0.5; double n_rfs = 9; string fa_name = string(args[1]); string directory = string(args[2]); if (n_args>3) intersection = atof(args[3]); if (n_args>4) n_rfs = atoi(args[4]); // Load training data MatrixXd inputs; MatrixXd targets; directory += "/"; if (!loadMatrix(directory+"inputs.txt", inputs)) return -1; if (!loadMatrix(directory+"targets.txt", targets)) return -1; int input_dim = inputs.cols(); // Initialize function approximator FunctionApproximator* fa; if (fa_name.compare("LWR")==0) { MetaParametersLWR* meta_params = new MetaParametersLWR(input_dim,n_rfs,intersection); fa = new FunctionApproximatorLWR(meta_params); } else { MetaParametersRBFN* meta_params = new MetaParametersRBFN(input_dim,n_rfs,intersection); fa = new FunctionApproximatorRBFN(meta_params); } // Train function approximator with data bool overwrite = true; fa->train(inputs,targets,directory,overwrite); // Make predictions for the targets MatrixXd outputs(inputs.rows(),fa->getExpectedOutputDim()); fa->predict(inputs,outputs); saveMatrix(directory,"outputs.txt",outputs,overwrite); VectorXd min(1); min << 0.0; VectorXd max(1); max << 2.0; VectorXi n_samples_grid(1); n_samples_grid << 201; fa->saveGridData(min, max, n_samples_grid, directory, overwrite); delete fa; return 0; }
/** Main function * \param[in] n_args Number of arguments * \param[in] args Arguments themselves * \return Success of exection. 0 if successful. */ int main(int n_args, char** args) { // First argument may be optional directory to write data to string directory; if (n_args>1) directory = string(args[1]); bool overwrite = true; // Generate training data int n_input_dims = 1; VectorXi n_samples_per_dim = VectorXi::Constant(1,25); if (n_input_dims==2) n_samples_per_dim = VectorXi::Constant(2,25); MatrixXd inputs, targets, outputs; targetFunction(n_samples_per_dim,inputs,targets); // Locally Weighted Regression double overlap = 0.07; int n_rfs = 9; if (n_input_dims==2) n_rfs = 5; VectorXi num_rfs_per_dim = VectorXi::Constant(n_input_dims,n_rfs); MetaParametersLWR* meta_parameters_lwr = new MetaParametersLWR(n_input_dims,num_rfs_per_dim,overlap); FunctionApproximator* fa = new FunctionApproximatorLWR(meta_parameters_lwr); cout << "_____________________________________" << endl << fa->getName() << endl; cout << " Training" << endl; fa->train(inputs,targets,directory+"/"+fa->getName(),overwrite); cout << " Predicting" << endl; fa->predict(inputs,outputs); meanAbsoluteErrorPerOutputDimension(targets,outputs); cout << endl << endl; delete fa; // IRFRLS int number_of_basis_functions=100; double lambda=0.2; double gamma=10; MetaParametersIRFRLS* meta_parameters_irfrls = new MetaParametersIRFRLS(n_input_dims,number_of_basis_functions,lambda,gamma); fa = new FunctionApproximatorIRFRLS(meta_parameters_irfrls); cout << "_____________________________________" << endl << fa->getName() << endl; cout << " Training" << endl; fa->train(inputs,targets,directory+"/"+fa->getName(),overwrite); cout << " Predicting" << endl; fa->predict(inputs,outputs); meanAbsoluteErrorPerOutputDimension(targets,outputs); cout << endl << endl; delete fa; /* // Gaussian Mixture Regression (TOO SLOW FOR DEMO) int number_of_gaussians = 5; MetaParametersGMR* meta_parameters_gmr = new MetaParametersGMR(n_input_dims,number_of_gaussians); fa = new FunctionApproximatorGMR(meta_parameters_gmr); cout << "_____________________________________" << endl << fa->getName() << endl; cout << " Training" << endl; fa->train(inputs,targets,directory+"/"+fa->getName(),overwrite); cout << " Predicting" << endl; fa->predict(inputs,outputs); meanAbsoluteErrorPerOutputDimension(targets,outputs); cout << endl << endl; delete fa; // Locally Weighted Projection Regression (LIBRARIES NOT LINKED CORRECTLY IN PYTHON) #ifdef USE_LWPR double w_gen=0.2; double w_prune=0.8; bool update_D=true; double init_alpha=0.1; double penalty=0.1; VectorXd init_D=VectorXd::Constant(n_input_dims,20); MetaParametersLWPR* meta_parameters_lwpr = new MetaParametersLWPR(n_input_dims,init_D,w_gen,w_prune,update_D,init_alpha,penalty); fa = new FunctionApproximatorLWPR(meta_parameters_lwpr); cout << "_____________________________________" << endl << fa->getName() << endl; cout << " Training" << endl; fa->train(inputs,targets,directory+"/"+fa->getName(),overwrite); cout << " Predicting" << endl; fa->predict(inputs,outputs); meanAbsoluteErrorPerOutputDimension(targets,outputs); cout << endl << endl; delete fa; #endif // USE_LWPR */ return 0; }
/** Main function * \param[in] n_args Number of arguments * \param[in] args Arguments themselves * \return Success of exection. 0 if successful. */ int main(int n_args, char** args) { string directory, directory_fa; if (n_args>1) directory = string(args[1]); bool overwrite = true; for (int n_input_dims = 1; n_input_dims<=2; n_input_dims++) { vector<FunctionApproximator*> function_approximators; if (n_args>2) { // Assume the arguments are names of function approximatores for (int i_arg=2; i_arg<n_args; i_arg++) { FunctionApproximator* fa = getFunctionApproximatorByName(args[i_arg],n_input_dims); if (fa==NULL) return -1; function_approximators.push_back(fa); } } else { // No name passed, get all function approximators getFunctionApproximatorsVector(n_input_dims,function_approximators); } // Generate training data VectorXi n_samples_per_dim = VectorXi::Constant(1,25); if (n_input_dims==2) n_samples_per_dim = VectorXi::Constant(2,10); MatrixXd inputs, targets, outputs; targetFunction(n_samples_per_dim,inputs,targets); VectorXd min = inputs.colwise().minCoeff(); VectorXd max = inputs.colwise().maxCoeff(); VectorXi n_samples_per_dim_dense = VectorXi::Constant(n_input_dims,100); if (n_input_dims==2) n_samples_per_dim = VectorXi::Constant(n_input_dims,40); for (unsigned int dd=0; dd<function_approximators.size(); dd++) { FunctionApproximator* fa = function_approximators[dd]; cout << "_____________________________________" << endl << fa->getName() << endl; cout << " Training (with " << n_input_dims << "D data)"<< endl; if (!directory.empty()) { directory_fa = directory+"/"+fa->getName(); if (n_input_dims==1) directory_fa = directory_fa+"1D"; else directory_fa = directory_fa+"2D"; } fa->train(inputs,targets,directory_fa,overwrite); fa->predict(inputs,outputs); cout << " Converting to UnifiedModel" << endl; UnifiedModel* mp_unified = fa->getUnifiedModel(); if (mp_unified!=NULL) { mp_unified->saveGridData(min, max, n_samples_per_dim_dense, directory_fa+"Unified",overwrite); fa->saveGridData(min, max, n_samples_per_dim_dense, directory_fa,overwrite); saveMatrix(directory_fa+"Unified","inputs.txt",inputs,overwrite); saveMatrix(directory_fa+"Unified","targets.txt",targets,overwrite); //saveMatrix(directory_fa+"Unified","outputs.txt",outputs,overwrite); } delete fa; fa = NULL; delete mp_unified; } } return 0; }