int main() { LinearRegression lr; vector<DataGroup> train_set; DataGroup train1, train2, train3, train4, train5; //y = 3 * x1 - 5 * x2 + 3; DataGroup test1; //1 1 1 train1.in.push_back(1); train1.in.push_back(1); train1.out.push_back(1); //1 -1 1 train2.in.push_back(2); train2.in.push_back(1); train2.out.push_back(4); //-1 1 1 train3.in.push_back(-1); train3.in.push_back(3); train3.out.push_back(-15); //0 0 1 train4.in.push_back(9); train4.in.push_back(1); train4.out.push_back(25); //-1 -1 0 train5.in.push_back(0); train5.in.push_back(1); train5.out.push_back(-2); train_set.push_back(train1); train_set.push_back(train2); train_set.push_back(train3); train_set.push_back(train4); train_set.push_back(train5); lr.train(train_set, 1e-5); test1.in.push_back(1); test1.in.push_back(1); test1.out.push_back(0); lr.predict(test1); cout << "result:" << test1.out[0] << endl; return 0; }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, zeroData ) { LinearRegression<double> lr; Array<double> x,y; x.push_back(0.0); x.push_back(0.0); y.push_back(1.0); y.push_back(2.0); TEST_THROW(lr.setData(x,y), std::logic_error); }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, trivialData ) { LinearRegression<double> lr; Array<double> x,y; x.push_back(0.0); x.push_back(1.0); y.push_back(0.0); y.push_back(1.0); lr.setData(x,y); TEST_EQUALITY_CONST( lr.getSlope(), 1.0 ); TEST_EQUALITY_CONST( lr.getYIntercept(), 0.0 ); }
int main(int argc, char* argv[]) { LinearRegression lr; LinearRegressionScoreTest lrst; LinearRegressionPermutationTest lrpt; Vector y; Matrix x; LoadVector("input.y", y); LoadMatrix("input.x", x); if (lr.FitLinearModel(x, y) == false) { fprintf(stderr, "Fitting failed!\n"); return -1; } Vector& beta = lr.GetCovEst(); Matrix& v = lr.GetCovB(); Vector& pWald = lr.GetAsyPvalue(); fprintf(stdout, "wald_beta\t"); Print(beta); fputc('\n', stdout); fprintf(stdout, "wald_vcov\t"); Print(v); fputc('\n', stdout); fprintf(stdout, "wald_p\t"); Print(pWald[1]); fputc('\n', stdout); if (lrpt.FitLinearModel(x, 1, y, 200, 0.05) == false) { fprintf(stderr, "Fitting failed!\n"); return -1; } fprintf(stdout, "permutation_p\t"); double permu_p = lrpt.getPvalue(); Print(permu_p); fputc('\n', stdout); if (lrst.FitLinearModel(x, y, 1) == false) { fprintf(stderr, "Fitting failed!\n"); return -1; } fprintf(stdout, "score_p\t"); double score_p = lrst.GetPvalue(); Print(score_p); fputc('\n', stdout); return 0; };
int main(int argc, char** argv) { QApplication app(argc, argv); std::vector<Eigen::Matrix<double, 2, 1> > data; LinearRegression<2> dist; for (double x = -10; x < 10; x += 0.01) { dist.setBasis((Eigen::Matrix<double, 1, 1>() << x).finished()); data.push_back(dist.getSample()); } ScatterPlot<2> plot("LinearRegressionRndScatterPlot1v", data); plot.show(); return app.exec(); }
int main(int argc, char** argv) { QApplication app(argc, argv); std::vector<Eigen::Matrix<double, 3, 1> > data; LinearRegression<3> dist; for (double x = -10; x < 10; x += 0.1) for (double y = -10; y < 10; y += 0.1) { dist.setBasis(Eigen::Matrix<double, 2, 1>(x, y)); data.push_back(dist.getSample()); } ScatterPlot<3> plot("LinearRegressionRndScatterPlot2v", data); plot.show(); return app.exec(); }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, nonUniqueXData ) { LinearRegression<double> lr; Array<double> x,y; x.push_back(0.0); x.push_back(1.0); x.push_back(1.0); y.push_back(0.0); y.push_back(0.5); y.push_back(1.5); lr.setData(x,y); double tol = 1.0e-10; TEST_FLOATING_EQUALITY( lr.getSlope(), 1.0, tol ); TEST_FLOATING_EQUALITY( lr.getYIntercept(), 0.0, tol ); }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, CoSineData ) { LinearRegression<double> lr; Array<double> x,y; int N = 11; double dt = 0.1; for (int i=0 ; i<N ; ++i) { double xval = dt*i; x.push_back( xval ); y.push_back( cos(xval) ); } lr.setData(x,y); // 1.0e-14 works on rancilio but not on gabriel, exetazo, or s858352 double tol = 1.0e-13; TEST_FLOATING_EQUALITY( lr.getSlope(), -4.653508042678562e-01, tol ); // These came from matlab TEST_FLOATING_EQUALITY( lr.getYIntercept(), 1.067025181571952, tol ); }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, SineData ) { LinearRegression<double> lr; Array<double> x,y; int N = 11; double dt = 0.1; for (int i=0 ; i<N ; ++i) { double xval = dt*i; x.push_back( xval ); y.push_back( sin(xval) ); } lr.setData(x,y); // 1.0e-14 works on rancilio but not on gabriel, exetazo, or s858352 double tol = 1.0e-13; TEST_FLOATING_EQUALITY( lr.getSlope(), 8.518189335013251e-01, tol ); // These came from matlab TEST_FLOATING_EQUALITY( lr.getYIntercept(), 2.989789515694744e-02, tol ); }
void LDA_predict(const std::string &year) { string type = "simulation"; //string modelFile = "LDA_result/" + year + "LDA_model_whole.csv"; string modelFile = "LDA_result/" + year + "LDA_model.csv"; string testFile = "training_set/" + type + "/" + year + "/" + year + "training_set_normalise" + ".csv"; string label_file = "training_set/" + type + "/" + year + "/" + year + "label_set" + ".csv"; // string label_file = "wholeTrainingset/" + year + "label_set_whole.csv"; LinearRegression lr; lr = LinearRegression(modelFile); arma::mat points; data::Load(testFile, points, true); // Load the test file data. // arma::mat points; // data::Load(training_file, points, true); // Perform the predictions using our model. arma::vec predictions; lr.Predict(points, predictions); // Save predictions. //predictions = arma::trans(predictions); string predictFile = "LDA_result/" + year + "LDA_prediction.csv"; data::Save(predictFile, predictions, true); std::vector<int> labels = read_line(label_file); std::vector<int> p = read_line (predictFile); int num = 0; if (p.size() == labels.size()) { for (unsigned i = 0; i < p.size(); i++) { if (p[i] > 0) { p[i] = 1; } else { p[i] = -1; } if (p[i] == labels[i]) { num++; } } } double rate = (double)num/(double)p.size(); std::cout<<num<<"/"<<p.size()<<" "<<rate<<endl; }
void ClothoidPath::OptimiseLine( const CarModel& cm, int idx, int step, double hLimit, PathPt* l3, const PathPt* l2, const PathPt* l4 ) { LinearRegression l; const int NSEG = m_pTrack->GetSize(); int i = (idx + NSEG - step) % NSEG; while( m_pPath[i].h > hLimit ) { l.Sample( m_pPath[i].pt.GetXY() ); i = (i + NSEG - step) % NSEG; } l.Sample( m_pPath[i].pt.GetXY() ); i = idx; while( m_pPath[i].h > hLimit ) { l.Sample( m_pPath[i].pt.GetXY() ); i = (i + step) % NSEG; } l.Sample( m_pPath[i].pt.GetXY() ); GfOut( "%4d ", idx ); Vec2d p, v; l.CalcLine( p, v ); double t; Utils::LineCrossesLine( l3->Pt().GetXY(), l3->Norm().GetXY(), p, v, t ); SetOffset( cm, 0, t, l3, l2, l4 ); }
Scalar computeLinearRegressionSlope(Array<Scalar>& x, Array<Scalar>& y) { LinearRegression<Scalar> lr; lr.setData(x,y); return(lr.getSlope()); }
/* Computes the linear regression for a series of measurements, the x-axis intercept of the regression line and its confidence interval, and writes a couple of files from which a nice plot of all this can be generated using the gnuplot program. */ bool computeRegressionAndWriteGnuplotFiles_(vector<double>::const_iterator const conc_vec_begin, vector<double>::const_iterator const conc_vec_end, vector<double>::const_iterator const area_vec_begin, double const confidence_p, String const filename_prefix, String const output_filename, String const format = "", bool const write_gnuplot = true ) { try { LinearRegression linreg; linreg.computeRegression(confidence_p, conc_vec_begin, conc_vec_end, area_vec_begin); if (write_gnuplot) { // the peak data goes here String datafilename(filename_prefix); datafilename += String(".dat"); ofstream dataout(datafilename.c_str()); // the gnuplot commands go here String commandfilename(filename_prefix); commandfilename += String(".cmd"); ofstream cmdout(commandfilename.c_str()); // the error bar for the x-axis intercept goes here String errorbarfilename(filename_prefix); errorbarfilename += String(".err"); ofstream errout(errorbarfilename.c_str()); // writing the commands cmdout << "set ylabel \"ion count\"\n" "set xlabel \"concentration\"\n" "set key left Left reverse\n"; if (!format.empty()) { if (format == "png") { cmdout << "set terminal png \n" "set output \"" << filename_prefix << ".png\"\n"; } else if (format == "eps") { cmdout << "set terminal postscript eps \n" "set output \"" << filename_prefix << ".eps\"\n"; } } cmdout << "plot \"" << datafilename << "\" w points ps 2 pt 1 lt 8 title \"data\" " // want data on first line of key ", " << linreg.getIntercept() << "+" << linreg.getSlope() << "*x lt 2 lw 3 title \"linear regression: " << linreg.getIntercept() << " + " << linreg.getSlope() << " * x\" " ", \"" << datafilename << "\" w points ps 2 pt 1 lt 8 notitle " // draw data a second time, on top of reg. line ", \"" << errorbarfilename << "\" using ($1):(0) w points pt 13 ps 2 lt 1 title \"x-intercept: " << linreg.getXIntercept() << "\" " ", \"" << errorbarfilename << "\" w xerrorbars lw 3 lt 1 title \"95% interval: [ " << linreg.getLower() << ", " << linreg.getUpper() << " ]\"\n"; cmdout.close(); // writing the x-axis intercept error bar errout << linreg.getXIntercept() << " 0 " << linreg.getLower() << " " << linreg.getUpper() << endl; errout.close(); // writing the peak data points vector<double>::const_iterator cit = conc_vec_begin; vector<double>::const_iterator ait = area_vec_begin; dataout.precision(writtenDigits<double>(0.0)); for (; cit != conc_vec_end; ++cit, ++ait) { dataout << *cit << ' ' << *ait << '\n'; } dataout.close(); } // end if (write_gnuplot) // write results to XML file ofstream results; results.open(output_filename.c_str()); results << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>" << endl; results << "<results_additiveseries>" << endl; results << "\t<slope>" << linreg.getSlope() << "</slope>" << endl; results << "\t<intercept>" << linreg.getIntercept() << "</intercept>" << endl; results << "\t<x_intercept>" << linreg.getXIntercept() << "</x_intercept>" << endl; results << "\t<confidence_lowerlimit>" << linreg.getLower() << "</confidence_lowerlimit>" << endl; results << "\t<confidence_upperlimit>" << linreg.getUpper() << "</confidence_upperlimit>" << endl; results << "\t<pearson_squared>" << linreg.getRSquared() << "</pearson_squared>" << endl; results << "\t<std_residuals>" << linreg.getStandDevRes() << "</std_residuals>" << endl; results << "\t<t_statistic>" << linreg.getTValue() << "</t_statistic>" << endl; results << "</results_additiveseries>" << endl; results.close(); } catch (string & s) { cout << s << endl; return 1; } return 0; }
void test_linearity() { Radix r; SimpleLSystemWithBranching sls; int b_index = 3; int grid_size = 10; //int grid_size = 5; int N = 10000; cv::Mat_<double> X(N, (grid_size - b_index - 2) * 2 + b_index); //cv::Mat_<double> X(N, (grid_size - 3) * 2 + 1); cv::Mat_<double> Y(N, grid_size * grid_size); for (int i = 0; i < N; ++i) { cv::Mat_<double> param(1, X.cols); for (int c = 0; c < X.cols; ++c) { param(0, c) = rand() % 3 - 1; } param.copyTo(X.row(i)); } cv::Mat_<double> X2(X.rows, X.cols); int count = 0; for (int i = 0; i < X.rows; ++i) { try { //cv::Mat_<double> density = sls.computeDensity(grid_size, X.row(i), true, true); cv::Mat_<double> density = sls.computeDensity(grid_size, X.row(i), true, false); density.copyTo(Y.row(count)); X.row(i).copyTo(X2.row(count)); count++; } catch (char* ex) { //cout << "conflict" << endl; } } ml::saveDataset("dataX.txt", X2(cv::Rect(0, 0, X2.cols, count))); ml::saveDataset("dataY.txt", Y(cv::Rect(0, 0, Y.cols, count))); //cv::Mat_<double> X, Y; ml::loadDataset("dataX.txt", X); ml::loadDataset("dataY.txt", Y); cv::Mat_<double> trainX, trainY; cv::Mat_<double> testX, testY; ml::splitDataset(X, 0.8, trainX, testX); ml::splitDataset(Y, 0.8, trainY, testY); // Forward { LinearRegression lr; lr.train(trainX, trainY); cv::Mat_<double> Y_hat = lr.predict(testX); cv::Mat_<double> Y_avg; cv::reduce(trainY, Y_avg, 0, CV_REDUCE_AVG); Y_avg = cv::repeat(Y_avg, testY.rows, 1); cout << "-----------------------" << endl; cout << "Forward:" << endl; cout << "RMSE: " << ml::rmse(testY, Y_hat, true) << endl; cout << "Baselime: " << ml::rmse(testY, Y_avg, true) << endl; } // Inverse { LinearRegression lr; lr.train(trainY, trainX); cv::Mat_<double> X_hat = lr.predict(testY); // Xの各値を-1,0,1にdiscretizeする { for (int r = 0; r < X_hat.rows; ++r) { for (int c = 0; c < X_hat.cols; ++c) { if (X_hat(r, c) < -0.5) { X_hat(r, c) = -1; } else if (X_hat(r,c ) > 0.5) { X_hat(r, c) = 1; } else { X_hat(r, c) = 0; } } } } for (int i = 0; i < testX.cols; ++i) { cout << ml::rmse(testX.col(i), X_hat.col(i), true) << endl; } cv::Mat_<double> Y_hat(testY.rows, testY.cols); for (int i = 0; i < testX.rows; ++i) { cv::Mat_<double> density_hat = sls.computeDensity(grid_size, X_hat.row(i), true, false); density_hat.copyTo(Y_hat.row(i)); } cv::Mat X_avg; cv::reduce(trainX, X_avg, 0, CV_REDUCE_AVG); double baselineX = ml::rmse(testX, cv::repeat(X_avg, testX.rows, 1), true); cv::Mat Y_avg = sls.computeDensity(grid_size, X_avg, true, false); //cv::reduce(trainY, Y_avg, 0, CV_REDUCE_AVG); double baselineY = ml::rmse(testY, cv::repeat(Y_avg, testY.rows, 1), true); cout << "-----------------------" << endl; cout << "Inverse:" << endl; cout << "RMSE in Parameter: " << ml::rmse(testX, X_hat, true) << endl; cout << "Baselime: " << baselineX << endl; cout << "RMSE in Indicator: " << ml::rmse(testY, Y_hat, true) << endl; cout << "Baseline: " << baselineY << endl; } }
int main(int argc, char** argv) { LinearRegression<2> linearRegression; std::cout << "Default parameters: " << std::endl << linearRegression << std::endl; std::cout << "l.getLinearBasisFunction(): " << std::endl << linearRegression.getLinearBasisFunction() << std::endl; std::cout << "l.getVariance(): " << linearRegression.getVariance() << std::endl; std::cout << "l.setLinearBasisFunction(2.0, 2.0)" << std::endl; std::cout << "l.setVariance(2.0)" << std::endl; std::cout << "l.setBasis(2.0)" << std::endl; linearRegression.setLinearBasisFunction(LinearBasisFunction<double, 2>( Eigen::Matrix<double, 2, 1>(2.0, 2.0))); linearRegression.setVariance(2.0); linearRegression.setBasis((Eigen::Matrix<double, 1, 1>() << 2.0).finished()); if (linearRegression.getLinearBasisFunction().getCoefficients() != Eigen::Matrix<double, 2, 1>(2.0, 2.0)) return 1; if (linearRegression.getVariance() != 2.0) return 1; if (linearRegression.getBasis() != (Eigen::Matrix<double, 1, 1>() << 2.0).finished()) return 1; std::cout << "New parameters: " << std::endl << linearRegression << std::endl; std::cout << "l.getValue(2): " << linearRegression( Eigen::Matrix<double, 2, 1>(2, 6)) << std::endl; std::cout << "l.getSample(): " << std::endl << linearRegression.getSample() << std::endl; std::cout << "l.getMean(): " << linearRegression.getMean() << std::endl; LinearRegression<2> linCopy(linearRegression); std::cout << "Copy constructor: " << std::endl << linCopy << std::endl << std::endl; if (linCopy.getLinearBasisFunction().getCoefficients() != linearRegression.getLinearBasisFunction().getCoefficients()) return 1; if (linCopy.getVariance() != linearRegression.getVariance()) return 1; LinearRegression<2> linAssign = linearRegression; std::cout << "Assignment operator: " << std::endl << linAssign << std::endl; if (linAssign.getLinearBasisFunction().getCoefficients() != linearRegression.getLinearBasisFunction().getCoefficients()) return 1; if (linAssign.getVariance() != linearRegression.getVariance()) return 1; return 0; }
int DataLoader::useResidualAsPhenotype() { if (binaryPhenotype) { logger->warn( "WARNING: Skip transforming binary phenotype, although you want to " "use residual as phenotype!"); return 0; } LinearRegression lr; Vector pheno; Matrix covAndInt; const int numCovariate = covariate.ncol(); copyPhenotype(phenotype, &pheno); copyCovariateAndIntercept(pheno.Length(), covariate, &covAndInt); if (!lr.FitLinearModel(covAndInt, pheno)) { if (numCovariate > 0) { logger->error( "Cannot fit model: [ phenotype ~ 1 + covariates ], now use the " "original phenotype"); } else { logger->error( "Cannot fit model: [ phenotype ~ 1 ], now use the " "original phenotype"); } } else { // linear model fitted successfully copyVectorToMatrixColumn(lr.GetResiduals(), &phenotype, 0); // const int n = lr.GetResiduals().Length(); // for (int i = 0; i < n; ++i) { // // phenotypeInOrder[i] = lr.GetResiduals()[i]; // phenotype[i][0] = lr.GetResiduals()[i]; // } covariate.clear(); if (numCovariate > 0) { logger->info( "DONE: Fit model [ phenotype ~ 1 + covariates ] and model " "residuals will be used as responses"); } else { logger->info("DONE: Use residual as phenotype by centerng it"); } // store fitting results Vector& beta = lr.GetCovEst(); Matrix& betaSd = lr.GetCovB(); const int n = beta.Length(); for (int i = 0; i < n; ++i) { addFittedParameter(covAndInt.GetColumnLabel(i), beta[i], betaSd[i][i]); } addFittedParameter("Sigma2", lr.GetSigma2(), NAN); } #if 0 if (covariate.ncol() > 0) { LinearRegression lr; Vector pheno; Matrix covAndInt; copyPhenotype(phenotype, &pheno); copyCovariateAndIntercept(covariate.nrow(), covariate, &covAndInt); if (!lr.FitLinearModel(covAndInt, pheno)) { logger->error( "Cannot fit model: [ phenotype ~ 1 + covariates ], now use the " "original phenotype"); } else { const int n = lr.GetResiduals().Length(); for (int i = 0; i < n; ++i) { // phenotypeInOrder[i] = lr.GetResiduals()[i]; phenotype[i][0] = lr.GetResiduals()[i]; } covariate.clear(); logger->info( "DONE: Fit model [ phenotype ~ 1 + covariates ] and model " "residuals will be used as responses"); } storeFittedModel(lr); } else { // no covaraites // centerVector(&phenotypeInOrder); std::vector<double> v; phenotype.extractCol(0, &v); centerVector(&v); phenotype.setCol(0, v); logger->info("DONE: Use residual as phenotype by centerng it"); } #endif return 0; }
static void mlpackMain() { const double lambda = CLI::GetParam<double>("lambda"); RequireOnlyOnePassed({ "training", "input_model" }, true); ReportIgnoredParam({{ "test", true }}, "output_predictions"); mat regressors; rowvec responses; LinearRegression lr; const bool computeModel = !CLI::HasParam("input_model"); const bool computePrediction = CLI::HasParam("test"); // If they specified a model file, we also need a test file or we // have nothing to do. if (!computeModel) { RequireAtLeastOnePassed({ "test" }, true, "test points must be specified " "when an input model is given"); } ReportIgnoredParam({{ "input_model", true }}, "lambda"); RequireAtLeastOnePassed({ "output_model", "output_predictions" }, false, "no output will be saved"); // An input file was given and we need to generate the model. if (computeModel) { Timer::Start("load_regressors"); regressors = std::move(CLI::GetParam<mat>("training")); Timer::Stop("load_regressors"); // Are the responses in a separate file? if (!CLI::HasParam("training_responses")) { // The initial predictors for y, Nx1. if (regressors.n_rows < 2) { Log::Fatal << "Can't get responses from training data " "since it has less than 2 rows." << endl; } responses = regressors.row(regressors.n_rows - 1); regressors.shed_row(regressors.n_rows - 1); } else { // The initial predictors for y, Nx1. Timer::Start("load_responses"); responses = CLI::GetParam<rowvec>("training_responses"); Timer::Stop("load_responses"); if (responses.n_cols != regressors.n_cols) { Log::Fatal << "The responses must have the same number of columns " "as the training set." << endl; } } Timer::Start("regression"); lr = LinearRegression(regressors, responses, lambda); Timer::Stop("regression"); } else { // A model file was passed in, so load it. Timer::Start("load_model"); lr = std::move(CLI::GetParam<LinearRegression>("input_model")); Timer::Stop("load_model"); } // Did we want to predict, too? if (computePrediction) { // Load the test file data. Timer::Start("load_test_points"); mat points = std::move(CLI::GetParam<mat>("test")); Timer::Stop("load_test_points"); // Ensure that test file data has the right number of features. if ((lr.Parameters().n_elem - 1) != points.n_rows) { Log::Fatal << "The model was trained on " << lr.Parameters().n_elem - 1 << "-dimensional data, but the test points in '" << CLI::GetPrintableParam<mat>("test") << "' are " << points.n_rows << "-dimensional!" << endl; } // Perform the predictions using our model. rowvec predictions; Timer::Start("prediction"); lr.Predict(points, predictions); Timer::Stop("prediction"); // Save predictions. if (CLI::HasParam("output_predictions")) CLI::GetParam<rowvec>("output_predictions") = std::move(predictions); } // Save the model if needed. if (CLI::HasParam("output_model")) CLI::GetParam<LinearRegression>("output_model") = std::move(lr); }
int main(int argc, char* argv[]) { // Handle parameters. CLI::ParseCommandLine(argc, argv); const string inputModelFile = CLI::GetParam<string>("input_model_file"); const string outputModelFile = CLI::GetParam<string>("output_model_file"); const string outputPredictionsFile = CLI::GetParam<string>("output_predictions"); const string trainingResponsesFile = CLI::GetParam<string>("training_responses"); const string testFile = CLI::GetParam<string>("test_file"); const string trainFile = CLI::GetParam<string>("training_file"); const double lambda = CLI::GetParam<double>("lambda"); mat regressors; mat responses; LinearRegression lr; lr.Lambda() = lambda; bool computeModel = false; // We want to determine if an input file XOR model file were given. if (!CLI::HasParam("training_file")) { if (!CLI::HasParam("input_model_file")) Log::Fatal << "You must specify either --input_file or --model_file." << endl; else // The model file was specified, no problems. computeModel = false; } // The user specified an input file but no model file, no problems. else if (!CLI::HasParam("input_model_file")) computeModel = true; // The user specified both an input file and model file. // This is ambiguous -- which model should we use? A generated one or given // one? Report error and exit. else { Log::Fatal << "You must specify either --input_file or --model_file, not " << "both." << endl; } if (CLI::HasParam("test_file") && !CLI::HasParam("output_predictions")) Log::Warn << "--test_file (-t) specified, but --output_predictions " << "(-o) is not; no results will be saved." << endl; // If they specified a model file, we also need a test file or we // have nothing to do. if (!computeModel && !CLI::HasParam("test_file")) { Log::Fatal << "When specifying --model_file, you must also specify " << "--test_file." << endl; } if (!computeModel && CLI::HasParam("lambda")) { Log::Warn << "--lambda ignored because no model is being trained." << endl; } // An input file was given and we need to generate the model. if (computeModel) { Timer::Start("load_regressors"); data::Load(trainFile, regressors, true); Timer::Stop("load_regressors"); // Are the responses in a separate file? if (CLI::HasParam("training_responses")) { // The initial predictors for y, Nx1. responses = trans(regressors.row(regressors.n_rows - 1)); regressors.shed_row(regressors.n_rows - 1); } else { // The initial predictors for y, Nx1. Timer::Start("load_responses"); data::Load(trainingResponsesFile, responses, true); Timer::Stop("load_responses"); if (responses.n_rows == 1) responses = trans(responses); // Probably loaded backwards. if (responses.n_cols > 1) Log::Fatal << "The responses must have one column.\n"; if (responses.n_rows != regressors.n_cols) Log::Fatal << "The responses must have the same number of rows as the " "training file.\n"; } Timer::Start("regression"); lr = LinearRegression(regressors, responses.unsafe_col(0)); Timer::Stop("regression"); // Save the parameters. if (CLI::HasParam("output_model_file")) data::Save(outputModelFile, "linearRegressionModel", lr); } // Did we want to predict, too? if (CLI::HasParam("test_file")) { // A model file was passed in, so load it. if (!computeModel) { Timer::Start("load_model"); data::Load(inputModelFile, "linearRegressionModel", lr, true); Timer::Stop("load_model"); } // Load the test file data. arma::mat points; Timer::Start("load_test_points"); data::Load(testFile, points, true); Timer::Stop("load_test_points"); // Ensure that test file data has the right number of features. if ((lr.Parameters().n_elem - 1) != points.n_rows) { Log::Fatal << "The model was trained on " << lr.Parameters().n_elem - 1 << "-dimensional data, but the test points in '" << testFile << "' are " << points.n_rows << "-dimensional!" << endl; } // Perform the predictions using our model. arma::vec predictions; Timer::Start("prediction"); lr.Predict(points, predictions); Timer::Stop("prediction"); // Save predictions. if (CLI::HasParam("output_predictions")) data::Save(outputPredictionsFile, predictions, true, false); } }
TEUCHOS_UNIT_TEST( Rythmos_ConvergenceTestHelpers, create ) { LinearRegression<double> lr; TEST_THROW(lr.getSlope(), std::logic_error); TEST_THROW(lr.getYIntercept(), std::logic_error); }
bool train( CommandLineParser &parser ){ infoLog << "Training regression model..." << endl; string trainDatasetFilename = ""; string modelFilename = ""; float learningRate = 0; float minChange = 0; unsigned int maxEpoch = 0; unsigned int batchSize = 0; //Get the filename if( !parser.get("filename",trainDatasetFilename) ){ errorLog << "Failed to parse filename from command line! You can set the filename using the -f." << endl; printHelp(); return false; } //Get the parameters from the parser parser.get("model-filename",modelFilename); parser.get( "learning-rate", learningRate ); parser.get( "min-change", minChange ); parser.get( "max-epoch", maxEpoch ); parser.get( "batch-size", batchSize ); infoLog << "settings: learning-rate: " << learningRate << " min-change: " << minChange << " max-epoch: " << maxEpoch << " batch-size: " << batchSize << endl; //Load the training data to train the model RegressionData trainingData; //Try and parse the input and target dimensions unsigned int numInputDimensions = 0; unsigned int numTargetDimensions = 0; if( parser.get("num-inputs",numInputDimensions) && parser.get("num-targets",numTargetDimensions) ){ infoLog << "num input dimensions: " << numInputDimensions << " num target dimensions: " << numTargetDimensions << endl; trainingData.setInputAndTargetDimensions( numInputDimensions, numTargetDimensions ); } if( (numInputDimensions == 0 || numTargetDimensions == 0) && Util::stringEndsWith( trainDatasetFilename, ".csv" ) ){ errorLog << "Failed to parse num input dimensions and num target dimensions from input arguments. You must supply the input and target dimensions if the data format is CSV!" << endl; printHelp(); return false; } infoLog << "- Loading Training Data..." << endl; if( !trainingData.load( trainDatasetFilename ) ){ errorLog << "Failed to load training data!\n"; return false; } const unsigned int N = trainingData.getNumInputDimensions(); const unsigned int T = trainingData.getNumTargetDimensions(); infoLog << "- Num training samples: " << trainingData.getNumSamples() << endl; infoLog << "- Num input dimensions: " << N << endl; infoLog << "- Num target dimensions: " << T << endl; //Create a new regression instance LinearRegression regression; regression.setMaxNumEpochs( maxEpoch ); regression.setMinChange( minChange ); regression.setUseValidationSet( true ); regression.setValidationSetSize( 20 ); regression.setRandomiseTrainingOrder( true ); regression.enableScaling( true ); //Create a new pipeline that will hold the regression algorithm GestureRecognitionPipeline pipeline; //Add a multidimensional regression instance and set the regression algorithm to Linear Regression pipeline.setRegressifier( MultidimensionalRegression( regression, true ) ); infoLog << "- Training model...\n"; //Train the classifier if( !pipeline.train( trainingData ) ){ errorLog << "Failed to train model!" << endl; return false; } infoLog << "- Model trained!" << endl; infoLog << "- Saving model to: " << modelFilename << endl; //Save the pipeline if( pipeline.save( modelFilename ) ){ infoLog << "- Model saved." << endl; }else warningLog << "Failed to save model to file: " << modelFilename << endl; infoLog << "- TrainingTime: " << pipeline.getTrainingTime() << endl; return true; }