SSAGES::ANNCV Class Reference

ANN (artifical neural network) collective variables. More...

#include <ANNCV.h>

Inheritance diagram for SSAGES::ANNCV:

Public Member Functions
	ANNCV (Label atomids, double scaling_factor, std::vector< unsigned int > num_nodes, std::string coeff_file, std::vector< std::string > activations, int out_index)
	Constructor. More...
void	Initialize (const Snapshot &snapshot) override
	Initialize necessary variables. More...
std::vector< Vector >	forward_prop (Vector &input_vec)
std::vector< Vector >	back_prop (std::vector< Vector > &output_of_layers)
void	Evaluate (const Snapshot &snapshot) override
	Evaluate the CV. More...
Public Member Functions inherited from SSAGES::CollectiveVariable
	CollectiveVariable ()
	Constructor.
virtual	~CollectiveVariable ()
	Destructor.
virtual void	Initialize (const class Snapshot &)
	Initialize CV. More...
virtual void	Evaluate (const class Snapshot &)=0
	Evaluate CV. More...
double	GetValue () const
	Get current value of the CV. More...
virtual double	GetMinimumImage (double) const
	Returns the minimum image of a CV based on the input location. More...
virtual double	GetPeriodicValue (double location) const
	Apply periodic boundaries to a given value. More...
const std::vector< Vector3 > &	GetGradient () const
	Get current gradient of the CV. More...
const Matrix3 &	GetBoxGradient () const
	Get gradient contribution to box. More...
const std::array< double, 2 > &	GetBoundaries ()
	Get CV boundaries. More...
virtual double	GetDifference (double location) const

Static Public Member Functions
static ANNCV *	Build (const Json::Value &json, const std::string &path)
	Set up collective variable. More...
Static Public Member Functions inherited from SSAGES::CollectiveVariable
static CollectiveVariable *	BuildCV (const Json::Value &json, const std::string &path)
	Set up collective variable. More...

Private Attributes
Label	atomids_
double	scaling_factor_
std::vector< unsigned int >	num_nodes_
std::vector< Eigen::MatrixXd >	weight_coeff_
std::vector< Vector >	bias_
std::vector< std::string >	activations_
int	out_index_

Additional Inherited Members
Protected Attributes inherited from SSAGES::CollectiveVariable
std::vector< Vector3 >	grad_
	Gradient vector dCv/dxi.
Matrix3	boxgrad_
	Gradient w.r.t box vectors dCv/dHij.
double	val_
	Current value of CV.
std::array< double, 2 >	bounds_
	Bounds on CV.

Detailed Description

ANN (artifical neural network) collective variables.

This CV takes scaled (specified by "scaling_factor") Cartesian coordinates of a group of atoms (specified by "atomids") as inputs to a neural network (its number of nodes, connection weights, and activation functions are specified by "num_nodes", "coeff_file", "activations", respectively), computes one component (specified by "out_index") of the final neural network outputs as the CV value.

Definition at line 42 of file ANNCV.h.

Constructor & Destructor Documentation

ANNCV()

SSAGES::ANNCV::ANNCV ( Label  atomids, double  scaling_factor, std::vector< unsigned int >  num_nodes, std::string  coeff_file, std::vector< std::string >  activations, int  out_index  )

inline

Constructor.

Parameters

atomids	atom IDs used as inputs to ANN
scaling_factor	scaling factor for input coordinates (input coordinates will be divided by this factor)
num_nodes	numbers of nodes for each layer of ANN
coeff_file	file storing weights and bias of ANN
activations	activations functions (as strings) of ANN
out_index	index of output component of ANN

Todo:

Bounds needs to be an input and periodic boundary conditions

Definition at line 66 of file ANNCV.h.

          :
            atomids_(atomids), scaling_factor_(scaling_factor), num_nodes_(num_nodes),
            activations_(activations), out_index_(out_index)
        {
            // read coefficients from file
            std::ifstream my_f(coeff_file);
            std::string temp_vec;
            int layer_index = 0;
            if (num_nodes_[0] != atomids_.size() * 3) {
                throw BuildException({
                    "WARNING: input dim should be " + std::to_string(atomids_.size() * 3) + " found: "
                    + std::to_string(num_nodes_[0])
                });
            }
            while (std::getline(my_f, temp_vec) )
            {
                std::istringstream ss(temp_vec);
                std::string token;
                std::vector<double> temp_weight, temp_bias;
                while (std::getline(ss, token, ','))  // coefficients are separated by comma
                {
                    temp_weight.push_back(stod(token));
                }
                if (temp_weight.size() != num_nodes_[layer_index] * num_nodes_[layer_index + 1]) {
                    throw BuildException({
                        "WARNING: layer weight size = " + std::to_string(temp_weight.size()) +  " expected: "
                        + std::to_string(num_nodes_[layer_index] * num_nodes_[layer_index + 1])
                    });
                }
                Eigen::Map<Eigen::MatrixXd> temp_weight_v(
                    &temp_weight[0], num_nodes_[layer_index], num_nodes_[layer_index + 1]
                );
                std::getline(my_f, temp_vec);
                std::istringstream ss2(temp_vec);
                while (std::getline(ss2, token, ','))
                {
                    temp_bias.push_back(stod(token));
                }
                if (temp_bias.size() != num_nodes_[layer_index + 1]) {
                    throw BuildException({
                        "WARNING: layer bias size = " + std::to_string(temp_bias.size())
                        + " expected: " + std::to_string(num_nodes_[layer_index + 1])
                    });
                }
                Vector temp_bias_v = Vector::Map(temp_bias.data(), temp_bias.size());
                weight_coeff_.push_back(temp_weight_v);
                bias_.push_back(temp_bias_v);
                layer_index ++;
            }
        }

Referenced by Build().

Here is the caller graph for this function:

Member Function Documentation

Build()

static ANNCV* SSAGES::ANNCV::Build ( const Json::Value &  json, const std::string &  path  )

inlinestatic

Set up collective variable.

Parameters

json	JSON input value.
path	Path for JSON path specification.

Returns

Pointer to the CV built by this function. nullptr in case of unknown error.

Builds a CV from a JSON node. Returns a pointer to the built cv. If an unknown error is encountered, this function will return a nullptr, but generally it will throw a BuildException on failure.

Warning

Object lifetime is the caller's responsibility.

Definition at line 244 of file ANNCV.h.

        {
            Json::ObjectRequirement validator;
            Json::Value schema;
            Json::CharReaderBuilder rbuilder;
            Json::CharReader* reader = rbuilder.newCharReader();
 
            reader->parse(JsonSchema::ANNCV.c_str(),
                          JsonSchema::ANNCV.c_str() + JsonSchema::ANNCV.size(),
                          &schema, NULL);
            validator.Parse(schema, path);
 
            // Validate inputs.
            validator.Validate(json, path);
            if(validator.HasErrors())
                throw BuildException(validator.GetErrors());
 
            std::vector<int> atomids;
            for(auto& s : json["atom_ids"])
                atomids.push_back(s.asInt());
            double scaling_factor = json["scaling_factor"].asDouble();
            std::vector<unsigned int> num_nodes;
            for (auto &s : json["num_nodes"])
                num_nodes.push_back(s.asUInt());
            std::vector<std::string> activations;
            std::string coeff_file = json["coeff_file"].asString();
            for (auto &s : json["activations"]) {
                auto name = s.asString();
                if (name == "Tanh" || name == "ReLU" || name == "Linear")
                    activations.push_back(name);
                else
                    throw std::runtime_error("invalid activation function " + name + " provided");
            }
            int out_index = json["index"].asInt();
            return new ANNCV(atomids, scaling_factor, num_nodes, coeff_file, activations, out_index);
        }

References ANNCV(), Json::Requirement::GetErrors(), Json::Requirement::HasErrors(), Json::ObjectRequirement::Parse(), and Json::ObjectRequirement::Validate().

Referenced by SSAGES::CollectiveVariable::BuildCV().

Here is the call graph for this function:

Here is the caller graph for this function:

Evaluate()

void SSAGES::ANNCV::Evaluate ( const Snapshot &  snapshot )

inlineoverride

Evaluate the CV.

Parameters

snapshot

Current simulation snapshot.

Definition at line 194 of file ANNCV.h.

        {
            // Get data from snapshot.
            auto n = snapshot.GetNumAtoms();
            const auto& pos = snapshot.GetPositions();
            auto& comm = snapshot.GetCommunicator();
 
            // Initialize gradient.
            std::fill(grad_.begin(), grad_.end(), Vector3{0,0,0});
            grad_.resize(n, Vector3{0,0,0});
 
            // Vector3 xi{0, 0, 0}, xj{0, 0, 0}, xk{0, 0, 0};
            std::vector<Vector3> positions(atomids_.size(), Vector3({0,0,0}));
            Label local_idx;
            snapshot.GetLocalIndices(atomids_, &local_idx);
            for (size_t ii = 0; ii < atomids_.size(); ii ++) {
                if (local_idx[ii] != -1) {
                    positions[ii] = pos[local_idx[ii]];
                }
            }
            // By performing a reduce, we actually collect all. This can
            // be converted to a more intelligent allgater on rank then bcast.
            MPI_Allreduce(MPI_IN_PLACE, positions.data(), positions.size(), MPI_DOUBLE, MPI_SUM, comm);
            auto com = snapshot.CenterOfMass(atomids_, false);  // center of mass coordinates (not weighted with mass)
            // remove translation degree of freedom
            for (auto& temp_pos: positions) {
                temp_pos = temp_pos - com;
            }
            Vector input_vec(positions.size() * 3);  // flatten input vector
            for (size_t ii = 0; ii < positions.size(); ii ++) {
                for (size_t jj = 0; jj < 3; jj ++) {
                    input_vec[ii * 3 + jj] = positions[ii][jj];
                }
            }
            input_vec = input_vec / scaling_factor_;
            auto output_of_layers = forward_prop(input_vec);
            val_ = output_of_layers[output_of_layers.size() - 1][out_index_];
            auto deriv_back = back_prop(output_of_layers);
            // subtract mean from deriv_back[0]
            int num_atoms = deriv_back[0].size() / 3;
            double average[3] = {0};
            for (int kk = 0; kk < 3; kk ++) {
                for (int ii = 0; ii < num_atoms; ii ++) {
                    average[kk] += deriv_back[0][ii * 3 + kk];
                }
                average[kk] /= num_atoms;
            }
        }

References SSAGES::Snapshot::CenterOfMass(), SSAGES::Snapshot::GetCommunicator(), SSAGES::Snapshot::GetLocalIndices(), SSAGES::Snapshot::GetNumAtoms(), SSAGES::Snapshot::GetPositions(), SSAGES::CollectiveVariable::grad_, and SSAGES::CollectiveVariable::val_.

Here is the call graph for this function:

Initialize()

void SSAGES::ANNCV::Initialize ( const Snapshot &  snapshot )

inlineoverride

Initialize necessary variables.

Parameters

snapshot

Current simulation snapshot.

Definition at line 128 of file ANNCV.h.

        {
            using std::to_string;
 
            std::vector<int> found;
            snapshot.GetLocalIndices(atomids_, &found);
            size_t nfound = found.size();
            MPI_Allreduce(MPI_IN_PLACE, &nfound, 1, MPI_INT, MPI_SUM, snapshot.GetCommunicator());
 
            if(nfound != atomids_.size())
                throw BuildException({
                    "ANNCV: Expected to find " +
                    to_string(atomids_.size()) +
                    " atoms, but only found " +
                    to_string(nfound) + "."
                });
        }

References SSAGES::Snapshot::GetCommunicator(), and SSAGES::Snapshot::GetLocalIndices().

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• /home/michael/development/SSAGES/src/CVs/ANNCV.h