void SGDSolver<Dtype>::RestoreSolverState(const SolverState& state) {
CHECK_EQ(state.history_size(), history_.size())
<< "Incorrect length of history blobs.";
LOG(INFO) << "SGDSolver: restoring history";
for (int i = 0; i < history_.size(); ++i) {
history_[i]->FromProto(state.history(i));
}
}
void Solver<Dtype>::Restore(const char* state_file) {
SolverState state;
NetParameter net_param;
ReadProtoFromBinaryFile(state_file, &state);
if (state.has_learned_net()) {
ReadProtoFromBinaryFile(state.learned_net().c_str(), &net_param);
net_->CopyTrainedLayersFrom(net_param);
}
iter_ = state.iter();
RestoreSolverState(state);
}
void Solver<Dtype>::Snapshot() {
NetParameter net_param;
// For intermediate results, we will also dump the gradient values.
net_->ToProto(&net_param, param_.snapshot_diff());
string filename(param_.snapshot_prefix());
char iter_str_buffer[20];
sprintf(iter_str_buffer, "_iter_%d", iter_);
filename += iter_str_buffer;
LOG(INFO)<< "Snapshotting to " << filename;
WriteProtoToBinaryFile(net_param, filename.c_str());
SolverState state;
SnapshotSolverState(&state);
state.set_iter(iter_);
state.set_learned_net(filename);
filename += ".solverstate";
LOG(INFO)<< "Snapshotting solver state to " << filename;
WriteProtoToBinaryFile(state, filename.c_str());
}
void Solver<Dtype>::Snapshot() {
NetParameter net_param;
// For intermediate results, we will also dump the gradient values.
net_->ToProto(&net_param, param_.snapshot_diff());
string filename(param_.snapshot_prefix());
string model_filename, snapshot_filename;
const int kBufferSize = 20;
char iter_str_buffer[kBufferSize];
snprintf(iter_str_buffer, kBufferSize, "_iter_%d", iter_);
filename += iter_str_buffer;
model_filename = filename + ".caffemodel";
LOG(INFO) << "Snapshotting to " << model_filename;
WriteProtoToBinaryFile(net_param, model_filename.c_str());
SolverState state;
SnapshotSolverState(&state);
state.set_iter(iter_);
state.set_learned_net(model_filename);
snapshot_filename = filename + ".solverstate";
LOG(INFO) << "Snapshotting solver state to " << snapshot_filename;
WriteProtoToBinaryFile(state, snapshot_filename.c_str());
}
int Epetra_TSFOperator::ApplyInverse(const Epetra_MultiVector& in, Epetra_MultiVector& out) const
{
TEST_FOR_EXCEPTION(solver_.ptr().get()==0, std::runtime_error,
"no solver provided for Epetra_TSFOperator::ApplyInverse");
TEST_FOR_EXCEPTION(!isNativeEpetra_ && !isCompoundEpetra_, std::runtime_error,
"Epetra_TSFOperator::ApplyInverse expects either "
"a native epetra operator or a compound operator with "
"Epetra domain and range spaces");
const Epetra_Vector* cevIn = dynamic_cast<const Epetra_Vector*>(&in);
Epetra_Vector* evIn = const_cast<Epetra_Vector*>(cevIn);
Epetra_Vector* evOut = dynamic_cast<Epetra_Vector*>(&out);
TEST_FOR_EXCEPTION(evIn==0, std::runtime_error, "Epetra_TSFOperator::Apply "
"cannot deal with multivectors");
TEST_FOR_EXCEPTION(evOut==0, std::runtime_error, "Epetra_TSFOperator::Apply "
"cannot deal with multivectors");
const EpetraVectorSpace* ed
= dynamic_cast<const EpetraVectorSpace*>(A_.range().ptr().get());
const EpetraVectorSpace* er
= dynamic_cast<const EpetraVectorSpace*>(A_.domain().ptr().get());
RCP<Thyra::VectorBase<double> > vpIn
= rcp(new EpetraVector(rcp(ed, false),
rcp(evIn, false)));
RCP<Thyra::VectorBase<double> > vpOut
= rcp(new EpetraVector(rcp(er, false),
rcp(evOut, false)));
Vector<double> vIn = vpIn;
Vector<double> vOut = vpOut;
SolverState<double> state = solver_.solve(A_, vIn, vOut);
if (state.finalState() == SolveCrashed) return -1;
else if (state.finalState() == SolveFailedToConverge) return -2;
else out = EpetraVector::getConcrete(vOut);
return 0;
}
void LinearPDEConstrainedObj::solveState(const Vector<double>& x) const
{
Tabs tab(0);
PLAYA_MSG2(verb(), tab << "solving state");
PLAYA_MSG3(verb(), tab << "|x|=" << x.norm2());
PLAYA_MSG5(verb(), tab << "x=" << endl << tab << x.norm2());
setDiscreteFunctionVector(designVarVal(), x);
/* solve the state equations in order */
for (int i=0; i<stateProbs_.size(); i++)
{
SolverState<double> status
= stateProbs_[i].solve(solvers_[i], stateVarVals(i));
TEUCHOS_TEST_FOR_EXCEPTION(status.finalState() != SolveConverged,
std::runtime_error,
"state equation could not be solved: status="
<< status.stateDescription());
}
PLAYA_MSG2(verb(), tab << "done state solve");
/* do postprocessing */
statePostprocCallback();
}
void SGDSolver<Dtype>::RestoreSolverStateFromBinaryProto(
const string& state_file) {
SolverState state;
ReadProtoFromBinaryFile(state_file, &state);
this->iter_ = state.iter();
if (state.has_learned_net()) {
NetParameter net_param;
ReadNetParamsFromBinaryFileOrDie(state.learned_net().c_str(), &net_param);
this->net_->CopyTrainedLayersFrom(net_param);
}
this->current_step_ = state.current_step();
CHECK_EQ(state.history_size(), history_.size())
<< "Incorrect length of history blobs.";
LOG(INFO) << "SGDSolver: restoring history";
for (int i = 0; i < history_.size(); ++i) {
history_[i]->FromProto(state.history(i));
}
}
void SGDSolver<Dtype>::SnapshotSolverStateToBinaryProto(
const string& model_filename) {
SolverState state;
state.set_iter(this->iter_);
state.set_learned_net(model_filename);
state.set_current_step(this->current_step_);
state.clear_history();
for (int i = 0; i < history_.size(); ++i) {
// Add history
BlobProto* history_blob = state.add_history();
history_[i]->ToProto(history_blob);
}
string snapshot_filename = Solver<Dtype>::SnapshotFilename(".solverstate");
LOG(INFO)
<< "Snapshotting solver state to binary proto file " << snapshot_filename;
WriteProtoToBinaryFile(state, snapshot_filename.c_str());
}
SolverState<double> PCGSolver::solveUnprec(const LinearOperator<double>& A,
const Vector<double>& b,
Vector<double>& x) const
{
Tabs tab0;
const ParameterList& params = parameters();
int verb = 0;
if (params.isParameter("Verbosity"))
{
verb = getParameter<int>(params, "Verbosity");
}
int maxIters = getParameter<int>(params, "Max Iterations");
double tol = getParameter<double>(params, "Tolerance");
/* Display diagnostic information if needed */
PLAYA_ROOT_MSG1(verb, tab0 << "Playa CG Solver");
Tabs tab1;
PLAYA_ROOT_MSG2(verb, tab0);
PLAYA_ROOT_MSG2(verb, tab1 << "Verbosity " << verb);
PLAYA_ROOT_MSG2(verb, tab1 << "Max Iters " << maxIters);
PLAYA_ROOT_MSG2(verb, tab1 << "Tolerance " << tol);
/* if the solution vector isn't initialized, set to RHS */
if (x.ptr().get()==0) x = b.copy();
Vector<double> r = b - A*x;
Vector<double> p = r.copy();
double bNorm = b.norm2();
PLAYA_ROOT_MSG2(verb, tab1 << "Problem size: " << b.space().dim());
PLAYA_ROOT_MSG2(verb, tab1 << "||rhs|| " << bNorm);
/* Prepare the status object to be returned */
SolverState<double> rtn;
bool converged = false;
bool shortcut = false;
/* Check for zero rhs */
if (bNorm==0.0)
{
PLAYA_ROOT_MSG2(verb, tab1 << "RHS is zero!");
rtn = SolverState<double>(SolveConverged, "Woo-hoo! Zero RHS shortcut",
0, 0.0);
shortcut = true;
}
double rNorm = 0.0;
double rtr = r*r;
if (!shortcut)
{
PLAYA_ROOT_MSG2(verb, tab1 << endl << tab1 << "CG Loop");
for (int k=0; k<maxIters; k++)
{
Tabs tab2;
Vector<double> Ap = A*p;
double alpha = rtr/(p*Ap);
x += alpha*p;
r -= alpha*Ap;
double rtrNew = r*r;
rNorm = sqrt(rtrNew);
PLAYA_ROOT_MSG2(verb, tab2 << "iter=" << setw(10)
<< k << setw(20) << "||r||=" << rNorm);
/* check relative residual */
if (rNorm < bNorm*tol)
{
rtn = SolverState<double>(SolveConverged, "Woo-hoo!",
k, rNorm);
converged = true;
break;
}
double beta = rtrNew/rtr;
rtr = rtrNew;
p = r + beta*p;
}
}
if (!converged && !shortcut)
{
rtn = SolverState<double>(SolveFailedToConverge,
"CG failed to converge",
maxIters, rNorm);
}
PLAYA_ROOT_MSG2(verb, tab0 << endl
<< tab0 << "CG finished with status "
<< rtn.stateDescription());
return rtn;
}
template <class Scalar> inline
SolverState<Scalar> BlockTriangularSolver<Scalar>
::solve(const LinearOperator<Scalar>& op,
const Vector<Scalar>& rhs,
Vector<Scalar>& soln) const
{
int nRows = op.numBlockRows();
int nCols = op.numBlockCols();
soln = op.domain().createMember();
// bool converged = false;
TEST_FOR_EXCEPTION(nRows != rhs.space().numBlocks(), std::runtime_error,
"number of rows in operator " << op
<< " not equal to number of blocks on RHS "
<< rhs);
TEST_FOR_EXCEPTION(nRows != nCols, std::runtime_error,
"nonsquare block structure in block triangular "
"solver: nRows=" << nRows << " nCols=" << nCols);
bool isUpper = false;
bool isLower = false;
for (int r=0; r<nRows; r++)
{
for (int c=0; c<nCols; c++)
{
if (op.getBlock(r,c).ptr().get() == 0 ||
dynamic_cast<const SimpleZeroOp<Scalar>* >(op.getBlock(r,c).ptr().get()))
{
TEST_FOR_EXCEPTION(r==c, std::runtime_error,
"zero diagonal block (" << r << ", " << c
<< " detected in block "
"triangular solver. Operator is " << op);
continue;
}
else
{
if (r < c) isUpper = true;
if (c < r) isLower = true;
}
}
}
TEST_FOR_EXCEPTION(isUpper && isLower, std::runtime_error,
"block triangular solver detected non-triangular operator "
<< op);
bool oneSolverFitsAll = false;
if ((int) solvers_.size() == 1 && nRows != 1)
{
oneSolverFitsAll = true;
}
for (int i=0; i<nRows; i++)
{
int r = i;
if (isUpper) r = nRows - 1 - i;
Vector<Scalar> rhs_r = rhs.getBlock(r);
for (int j=0; j<i; j++)
{
int c = j;
if (isUpper) c = nCols - 1 - j;
if (op.getBlock(r,c).ptr().get() != 0)
{
rhs_r = rhs_r - op.getBlock(r,c) * soln.getBlock(c);
}
}
SolverState<Scalar> state;
Vector<Scalar> soln_r;
if (oneSolverFitsAll)
{
state = solvers_[0].solve(op.getBlock(r,r), rhs_r, soln_r);
}
else
{
state = solvers_[r].solve(op.getBlock(r,r), rhs_r, soln_r);
}
if (nRows > 1) soln.setBlock(r, soln_r);
else soln = soln_r;
if (state.finalState() != SolveConverged)
{
return state;
}
}
return SolverState<Scalar>(SolveConverged, "block solves converged",
0, ScalarTraits<Scalar>::zero());
}
int main(int argc, char *argv[])
{
try
{
GlobalMPISession session(&argc, &argv);
MPIComm::world().synchronize();
/* create the nonlinear operator */
VectorType<double> type = new EpetraVectorType();
int nProc = MPIComm::world().getNProc();
int nLocalRows = 128/nProc;
PoissonBoltzmannOp* prob = new PoissonBoltzmannOp(nLocalRows, type);
NonlinearOperator<double> F = prob;
/* create the nox solver */
ParameterXMLFileReader reader("nox.xml");
ParameterList noxParams = reader.getParameters();
Out::root() << "solver params = " << noxParams << std::endl;
NOXSolver solver(noxParams);
Vector<double> soln;
SolverState<double> stat = solver.solve(F, soln);
TEUCHOS_TEST_FOR_EXCEPTION(stat.finalState() != SolveConverged,
runtime_error, "solve failed");
Out::root() << "numerical solution = " << std::endl;
Out::os() << soln << std::endl;
Vector<double> exact = prob->exactSoln();
Out::root() << "exact solution = " << std::endl;
Out::os() << exact << std::endl;
//bvbw reddish port hack
double temp_val = nLocalRows*nProc;
double err = (exact-soln).norm2()/sqrt(temp_val);
Out::root() << "error norm = " << err << std::endl;
double tol = 1.0e-6;
if (err > tol)
{
Out::root() << "NOX Poisson-Boltzmann test FAILED" << std::endl;
return 1;
}
else
{
Out::root() << "NOX Poisson-Boltzmann test PASSED" << std::endl;
return 0;
}
}
catch(std::exception& e)
{
Out::root() << "Caught exception: " << e.what() << std::endl;
return -1;
}
}
int main(int argc, char** argv)
{
try
{
Sundance::init(&argc, &argv);
/* We will do our linear algebra using Epetra */
VectorType<double> vecType = new EpetraVectorType();
/* Create a mesh. It will be of type BasisSimplicialMesh, and will
* be built using a PartitionedLineMesher. */
MeshType meshType = new BasicSimplicialMeshType();
int nx = 32;
MeshSource mesher = new PartitionedRectangleMesher(
0.0, 1.0, nx,
0.0, 1.0, nx,
meshType);
Mesh mesh = mesher.getMesh();
/* Create a cell filter that will identify the maximal cells
* in the interior of the domain */
CellFilter interior = new MaximalCellFilter();
/* Make cell filters for the east and west boundaries */
CellFilter edges = new DimensionalCellFilter(1);
CellFilter west = edges.coordSubset(0, 0.0);
CellFilter east = edges.coordSubset(0, 1.0);
/* Create unknown and test functions */
Expr u = new UnknownFunction(new Lagrange(1), "u");
Expr v = new TestFunction(new Lagrange(1), "v");
/* Create differential operator and coordinate function */
Expr x = new CoordExpr(0);
Expr grad = gradient(1);
/* We need a quadrature rule for doing the integrations */
QuadratureFamily quad = new GaussianQuadrature(4);
/* Define the parameter */
Expr xi = new Sundance::Parameter(0.0);
/* Construct a forcing term to provide an exact solution for
* validation purposes. This will involve the parameter. */
Expr uEx = x*(1.0-x)*(1.0+xi*exp(x));
Expr f = -(-20 - exp(x)*xi*(1 + 32*x + 10*x*x +
exp(x)*(-1 + 2*x*(2 + x))*xi))/10.0;
/* Define the weak form, using the parameter expression. This weak form
* can be used for all parameter values. */
Expr eqn = Integral(interior,
(1.0 + 0.1*xi*exp(x))*(grad*v)*(grad*u) - f*v, quad);
/* Define the Dirichlet BC */
Expr h = new CellDiameterExpr();
Expr bc = EssentialBC(east + west, v*u/h, quad);
/* We can now set up the linear problem. This can be reused
* for different parameter values. */
LinearProblem prob(mesh, eqn, bc, v, u, vecType);
/* make a projector for the exact solution. Just like the
* problem, this can be reused for different parameter values. */
DiscreteSpace ds(mesh, new Lagrange(1), vecType);
L2Projector proj(ds, uEx);
/* Get the solver and declare variables for the results */
LinearSolver<double> solver = LinearSolverBuilder::createSolver("aztec-ml.xml");
Expr soln;
SolverState<double> state;
/* Set up the sweep from xi=0 to xi=xiMax in nSteps steps. */
int nSteps = 10;
double xiMax = 2.0;
/* Make an array in which to keep the observed errors */
Array<double> err(nSteps);
/* Do the sweep */
for (int n=0; n<nSteps; n++)
{
/* Update the parameter value */
double xiVal = xiMax*n/(nSteps - 1.0);
xi.setParameterValue(xiVal);
Out::root() << "step n=" << n << " of " << nSteps << " xi=" << xiVal;
/* Solve the problem. The updated parameter value is automatically used. */
state = prob.solve(solver, soln);
TEUCHOS_TEST_FOR_EXCEPTION(state.finalState() != SolveConverged,
std::runtime_error,
"solve failed!");
/* Project the exact solution onto a discrrete space for viz. The updated
* parameter value is automatically used. */
Expr uEx0 = proj.project();
/* Write the approximate and exact solutions for viz */
FieldWriter w = new VTKWriter("ParameterSweep-" + Teuchos::toString(n));
w.addMesh(mesh);
w.addField("u", new ExprFieldWrapper(soln[0]));
w.addField("uEx", new ExprFieldWrapper(uEx0[0]));
w.write();
/* Compute the L2 norm of the error */
err[n] = L2Norm(mesh, interior, soln-uEx, quad);
Out::root() << " L2 error = " << err[n] << endl;
}
/* The errors are O(h^2), so use that to set a tolerance */
double hVal = 1.0/(nx-1.0);
double fudge = 2.0;
double tol = fudge*hVal*hVal;
/* Find the max error over all parameter values */
double maxErr = *std::max_element(err.begin(), err.end());
/* Check the error */
Sundance::passFailTest(maxErr, tol);
}
catch(std::exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize();
return Sundance::testStatus();
}
void LinearPDEConstrainedObj
::solveStateAndAdjoint(const Vector<double>& x) const
{
Tabs tab(0);
PLAYA_MSG2(verb(), tab << "solving state and adjoint");
PLAYA_MSG3(verb(), tab << "|x|=" << x.norm2());
PLAYA_MSG5(verb(), tab << "x=" << endl << tab << x.norm2());
Tabs tab1;
setDiscreteFunctionVector(designVarVal(), x);
PLAYA_MSG3(verb(), tab1 << "solving state eqns");
/* solve the state equations in order */
for (int i=0; i<stateProbs_.size(); i++)
{
SolverState<double> status
= stateProbs_[i].solve(solvers_[i], stateVarVals(i));
/* if the solve failed, write out the design var and known state
* variables */
if (status.finalState() != SolveConverged)
{
FieldWriter w = new VTKWriter("badSolve");
w.addMesh(Lagrangian().mesh());
w.addField("designVar", new ExprFieldWrapper(designVarVal()));
for (int j=0; j<i; j++)
{
Expr tmp = stateVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("stateVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
w.write();
}
TEUCHOS_TEST_FOR_EXCEPTION(status.finalState() != SolveConverged,
std::runtime_error,
"state equation " << i
<< " could not be solved: status="
<< status.stateDescription());
}
PLAYA_MSG3(verb(), tab1 << "done solving state eqns");
/* do postprocessing */
statePostprocCallback();
PLAYA_MSG3(verb(), tab1 << "solving adjoint eqns");
/* solve the adjoint equations in reverse order */
for (int i=adjointProbs_.size()-1; i>=0; i--)
{
SolverState<double> status
= adjointProbs_[i].solve(solvers_[i], adjointVarVals(i));
/* if the solve failed, write out the design var and known state
* and adjoint variables */
if (status.finalState() != SolveConverged)
{
FieldWriter w = new VTKWriter("badSolve");
w.addMesh(Lagrangian().mesh());
w.addField("designVar", new ExprFieldWrapper(designVarVal()));
for (int j=0; j<stateProbs_.size(); j++)
{
Expr tmp = stateVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("stateVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
for (int j=adjointProbs_.size()-1; j>i; j--)
{
Expr tmp = adjointVarVals(j).flatten();
for (int k=0; k<tmp.size(); k++)
{
w.addField("adjointVar-"+Teuchos::toString(j)+"-"+Teuchos::toString(k),
new ExprFieldWrapper(tmp[k]));
}
}
w.write();
}
TEUCHOS_TEST_FOR_EXCEPTION(status.finalState() != SolveConverged,
std::runtime_error,
"adjoint equation " << i
<< " could not be solved: status="
<< status.stateDescription());
}
PLAYA_MSG3(verb(), tab1 << "done solving adjoint eqns");
PLAYA_MSG2(verb(), tab1 << "done solving state and adjoint eqns");
}
int main(int argc, char** argv)
{
try
{
int nx = 32;
double convTol = 1.0e-8;
double lambda = 0.5;
Sundance::setOption("nx", nx, "Number of elements");
Sundance::setOption("tol", convTol, "Convergence tolerance");
Sundance::setOption("lambda", lambda, "Lambda (parameter in Bratu's equation)");
Sundance::init(&argc, &argv);
Out::root() << "Bratu problem (lambda=" << lambda << ")" << endl;
Out::root() << "Newton's method with automated linearization"
<< endl << endl;
VectorType<double> vecType = new EpetraVectorType();
MeshType meshType = new BasicSimplicialMeshType();
MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, nx, meshType);
Mesh mesh = mesher.getMesh();
CellFilter interior = new MaximalCellFilter();
CellFilter sides = new DimensionalCellFilter(mesh.spatialDim()-1);
CellFilter left = sides.subset(new CoordinateValueCellPredicate(0, 0.0));
CellFilter right = sides.subset(new CoordinateValueCellPredicate(0, 1.0));
BasisFamily basis = new Lagrange(1);
Expr u = new UnknownFunction(basis, "w");
Expr v = new TestFunction(basis, "v");
Expr grad = gradient(1);
Expr x = new CoordExpr(0);
const double pi = 4.0*atan(1.0);
Expr uExact = sin(pi*x);
Expr R = pi*pi*uExact - lambda*exp(uExact);
QuadratureFamily quad4 = new GaussianQuadrature(4);
QuadratureFamily quad2 = new GaussianQuadrature(2);
DiscreteSpace discSpace(mesh, basis, vecType);
Expr uPrev = new DiscreteFunction(discSpace, 0.5);
Expr eqn
= Integral(interior, (grad*v)*(grad*u) - v*lambda*exp(u) - v*R, quad4);
Expr h = new CellDiameterExpr();
Expr bc = EssentialBC(left+right, v*u/h, quad2);
NonlinearProblem prob(mesh, eqn, bc, v, u, uPrev, vecType);
NonlinearSolver<double> solver
= NonlinearSolverBuilder::createSolver("playa-newton-amesos.xml");
Out::root() << "Newton solve" << endl;
SolverState<double> state = prob.solve(solver);
TEUCHOS_TEST_FOR_EXCEPTION(state.finalState() != SolveConverged,
std::runtime_error,
"Nonlinear solve failed to converge: message=" << state.finalMsg());
Expr soln = uPrev;
FieldWriter writer = new DSVWriter("AutoLinearizedBratu.dat");
writer.addMesh(mesh);
writer.addField("soln", new ExprFieldWrapper(soln[0]));
writer.write();
Out::root() << "Converged!" << endl << endl;
double L2Err = L2Norm(mesh, interior, soln-uExact, quad4);
Out::root() << "L2 Norm of error: " << L2Err << endl;
Sundance::passFailTest(L2Err, 1.5/((double) nx*nx));
}
catch(std::exception& e)
{
Sundance::handleException(e);
}
Sundance::finalize();
return Sundance::testStatus();
}