void unlock(size_t thread_index)
{
//dbgl("unlock", thread_index);
std::vector<size_t> indexes = get_indexes(thread_index);
for (int i = indexes.size() - 1; i >= 0; --i)
mutexes_[(indexes[i] - 1) / 2].unlock(indexes[i] % 2);
}
double ExampleSubsetFilterTable::get_strength(
const domino::Subset& cur_subset,
const domino::Subsets& prior_subsets) const {
IMP_OBJECT_LOG;
if (get_indexes(cur_subset, prior_subsets).size() != ps_.size()) {
return 0;
} else {
// pick some number
return .5;
}
}
ModelObjectsTemp RefinedPairsPairScore::do_get_inputs(
kernel::Model *m, const kernel::ParticleIndexes &pis) const {
kernel::ParticleIndexes ps;
for (unsigned int i = 0; i < pis.size(); ++i) {
ps += get_indexes(get_set(m->get_particle(pis[i]), r_));
}
kernel::ModelObjectsTemp ret;
ret += f_->get_inputs(m, ps);
ret += r_->get_inputs(m, ps);
return ret;
}
ParticleIndexes Refiner::get_refined_indexes(Model *m,
ParticleIndex pi) const {
ParticlesTemp ps = get_refined( m->get_particle(pi) );
IMP_IF_CHECK(USAGE_AND_INTERNAL) {
for(unsigned int i = 0; i < ps.size(); i++) {
if (ps[i]->get_model() != m) {
IMP_THROW("Refined particles model does not match parent model - "
"this is critical if get_refined_indexes() is used.",
IMP::ValueException);
}
}
}
return get_indexes(ps);
}
core::MonteCarloMoverResult BallMover::do_propose() {
IMP_OBJECT_LOG;
// random displacement
algebra::Vector3D displacement = algebra::get_random_vector_in(
algebra::Sphere3D(algebra::Vector3D(0.0, 0.0, 0.0), max_tr_));
// store old coordinates of master particle
oldcoord_ = core::XYZ(p_).get_coordinates();
// master particle coordinates after displacement
algebra::Vector3D nc = oldcoord_ + displacement;
// find center of the closest cell
double mindist = 1.0e+24;
unsigned icell = 0;
for (unsigned i = 0; i < ctrs_.size(); ++i) {
// calculate distance between nc and cell center
double dist = algebra::get_l2_norm(nc - ctrs_[i]);
// find minimum distance
if (dist < mindist) {
mindist = dist;
icell = i;
}
}
// find inverse transformation
algebra::Transformation3D cell_tr = trs_[icell].get_inverse();
// set new coordinates for master particle
core::XYZ(p_).set_coordinates(cell_tr.get_transformed(nc));
// set new coordinates for slave particles
oldcoords_.clear();
for (unsigned i = 0; i < ps_.size(); ++i) {
core::XYZ xyz = core::XYZ(ps_[i]);
algebra::Vector3D oc = xyz.get_coordinates();
// store old coordinates
oldcoords_.push_back(oc);
// apply transformation
algebra::Vector3D nc = cell_tr.get_transformed(oc);
xyz.set_coordinates(nc);
}
ParticlesTemp ret;
ret.push_back(p_);
ret.insert(ret.end(), ps_.begin(), ps_.end());
return core::MonteCarloMoverResult(get_indexes(ret), 1.0);
}
domino::SubsetFilter* ExampleSubsetFilterTable::get_subset_filter(
const domino::Subset& cur_subset,
const domino::Subsets& prior_subsets) const {
IMP_OBJECT_LOG;
Ints its = get_indexes(cur_subset, prior_subsets);
if (its.size() != ps_.size()) {
// either the subset doesn't contain the needed particles or the prior does
return nullptr;
} else {
IMP_NEW(ExampleSubsetFilter, ret, (its, max_diff_));
// remember to release
return ret.release();
}
}
ParticleIndexPairs ConsecutivePairContainer::get_all_possible_indexes() const {
return get_indexes();
}
// backwards compat
NormalMover::NormalMover(const ParticlesTemp &sc, double max)
: MonteCarloMover(sc[0]->get_model(), "XYZNormalMover%1%") {
initialize(get_indexes(sc), XYZ::get_xyz_keys(), max);
}
core::MonteCarloMoverResult RigidBodyMover::do_propose() {
IMP_OBJECT_LOG;
// store last reference frame of master rigid body
oldtr_ = d_.get_reference_frame().get_transformation_to();
// generate new coordinates of center of mass of master rb
algebra::Vector3D nc = algebra::get_random_vector_in(
algebra::Sphere3D(d_.get_coordinates(), max_tr_));
// find center of the closest cell
double mindist = 1.0e+24;
unsigned icell = 0;
for (unsigned int i = 0; i < ctrs_.size(); ++i) {
// calculate distance between nc and cell center
double dist = algebra::get_l2_norm(nc - ctrs_[i]);
// find minimum distance
if (dist < mindist) {
mindist = dist;
icell = i;
}
}
// find inverse transformation
algebra::Transformation3D cell_tr = trs_[icell].get_inverse();
// r: rotation around random axis
algebra::VectorD<3> axis = algebra::get_random_vector_on(
algebra::Sphere3D(algebra::VectorD<3>(0.0, 0.0, 0.0), 1.));
::boost::uniform_real<> rand(-max_ang_, max_ang_);
Float angle = rand(random_number_generator);
algebra::Rotation3D r = algebra::get_rotation_about_axis(axis, angle);
// ri: composing rotation of reference frame transformation and
// rotation due to boundary-crossing
algebra::Rotation3D ri =
cell_tr.get_rotation() *
d_.get_reference_frame().get_transformation_to().get_rotation();
// rc: composing ri with random rotation r
algebra::Rotation3D rc = r * ri;
// new reference frame for master rb
d_.set_reference_frame(algebra::ReferenceFrame3D(
algebra::Transformation3D(rc, cell_tr.get_transformed(nc))));
// set new coordinates for slave particles
oldcoords_.clear();
for (unsigned i = 0; i < ps_norb_.size(); ++i) {
core::XYZ xyz = core::XYZ(ps_norb_[i]);
algebra::Vector3D oc = xyz.get_coordinates();
// store old coordinates
oldcoords_.push_back(oc);
// apply cell transformation
algebra::Vector3D nc = cell_tr.get_transformed(oc);
xyz.set_coordinates(nc);
}
// set new reference frames for slave rbs
oldtrs_.clear();
for (unsigned i = 0; i < rbs_.size(); ++i) {
algebra::Transformation3D ot =
rbs_[i].get_reference_frame().get_transformation_to();
// store old reference frame transformation
oldtrs_.push_back(ot);
// create new reference frame
algebra::Rotation3D rr = cell_tr.get_rotation() * ot.get_rotation();
algebra::Vector3D tt = cell_tr.get_transformed(rbs_[i].get_coordinates());
// set new reference frame for slave rbs
rbs_[i].set_reference_frame(
algebra::ReferenceFrame3D(algebra::Transformation3D(rr, tt)));
}
ParticlesTemp ret = ParticlesTemp(1, d_);
ret.insert(ret.end(), ps_.begin(), ps_.end());
return core::MonteCarloMoverResult(get_indexes(ret), 1.0);
}
PLURALVARIABLETYPE ClassnameContainer::get_FUNCTIONNAMEs() const {
return IMP::internal::get_particle(get_model(), get_indexes());
}
// backwards compat
NormalMover::NormalMover(const ParticlesTemp &sc, const FloatKeys &vars,
double max)
: MonteCarloMover(sc[0]->get_model(), "NormalMover%1%") {
initialize(get_indexes(sc), vars, max);
}
ParticleIndexes Refiner::get_refined_indexes(kernel::Model *m,
ParticleIndex pi) const {
return get_indexes(get_refined(m->get_particle(pi)));
}
double NN_cost_function(int num_threads, matrix_t** gradient, matrix_t* rolled_theta, unsigned int layer_sizes[], unsigned int num_layers,
unsigned int num_labels, matrix_t* X, matrix_t* y, double lamda)
{
unsigned int theta_sizes[][2] = {{25, 401}, {10, 26}};
matrix_list_t* theta = unroll_matrix_list(rolled_theta, num_layers-1, theta_sizes);
unsigned int m = X->rows;
//unsigned int n = X->cols;
matrix_list_t* theta_gradient_total = matrix_list_constructor(theta->num);
unsigned int i, j;
for(i=0; i<theta_gradient_total->num; i++)
{
theta_gradient_total->matrix_list[i] = matrix_constructor(theta->matrix_list[i]->rows, theta->matrix_list[i]->cols);
}
omp_set_num_threads(num_threads);
int nthreads, tid;
#pragma omp parallel private(nthreads, tid)
{
int indexes[2];
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
get_indexes(m, nthreads, tid, indexes);
unsigned int i, j;
matrix_t* temp;
matrix_t* temp2;
matrix_t* temp3;
matrix_list_t* theta_gradient = matrix_list_constructor(theta->num);
for(i=0; i<theta_gradient->num; i++)
{
theta_gradient->matrix_list[i] = matrix_constructor(theta->matrix_list[i]->rows, theta->matrix_list[i]->cols);
}
for(i=indexes[0]; i<indexes[1]; i++)
{
matrix_list_t* A = matrix_list_constructor(num_layers);
matrix_list_t* Z = matrix_list_constructor(num_layers-1);
matrix_list_t* delta = matrix_list_constructor(num_layers-1);
A->matrix_list[0] = row_to_vector(X, i);
temp = matrix_prepend_col(A->matrix_list[0], 1.0);
free_matrix(A->matrix_list[0]);
A->matrix_list[0] = matrix_transpose(temp);
free_matrix(temp);
for(j=0; j<num_layers-1; j++)
{
Z->matrix_list[j] = matrix_multiply(theta->matrix_list[j], A->matrix_list[j]);
temp = matrix_sigmoid(Z->matrix_list[j]);
A->matrix_list[j+1] = matrix_prepend_row(temp, 1.0);
free_matrix(temp);
}
temp = matrix_remove_row(A->matrix_list[num_layers-1]);
free_matrix(A->matrix_list[num_layers-1]);
A->matrix_list[num_layers-1] = temp;
matrix_t* result_matrix = matrix_constructor(1, num_labels);
for(j = 0; j < num_labels; j++)
{
if(vector_get(y, i) == j)
{
vector_set(result_matrix, j, 1.0);
}
}
temp = matrix_transpose(result_matrix);
free_matrix(result_matrix);
result_matrix= temp;
delta->matrix_list[1] = matrix_subtract(A->matrix_list[num_layers-1], result_matrix);
free_matrix(result_matrix);
matrix_t* theta_transpose = matrix_transpose(theta->matrix_list[1]);
temp = matrix_multiply(theta_transpose, delta->matrix_list[1]);
matrix_t* sig_gradient = matrix_sigmoid_gradient(Z->matrix_list[0]);
temp2 = matrix_prepend_row(sig_gradient, 1.0);
temp3 = matrix_cell_multiply(temp, temp2);
delta->matrix_list[0] = matrix_remove_row(temp3);
free_matrix(temp);
free_matrix(temp2);
free_matrix(temp3);
free_matrix(sig_gradient);
free_matrix(theta_transpose);
for(j=0; j<num_layers-1; j++)
{
matrix_t* A_transpose = matrix_transpose(A->matrix_list[j]);
temp = matrix_multiply(delta->matrix_list[j], A_transpose);
temp2 = matrix_add(theta_gradient->matrix_list[j], temp);
free_matrix(theta_gradient->matrix_list[j]);
theta_gradient->matrix_list[j] = temp2;
free_matrix(A_transpose);
free_matrix(temp);
}
free_matrix_list(A);
free_matrix_list(Z);
free_matrix_list(delta);
}
#pragma omp critical
{
matrix_list_t* temp_list;
temp_list = matrix_list_add(theta_gradient_total, theta_gradient);
free_matrix_list(theta_gradient_total);
free_matrix_list(theta_gradient);
theta_gradient_total = temp_list;
}
}
for(i=0; i<num_layers-1; i++)
{
matrix_t* temp;
matrix_t* temp2;
matrix_t* temp3;
temp = matrix_scalar_multiply(theta_gradient_total->matrix_list[i], 1.0/m);
temp2 = copy_matrix(theta->matrix_list[i]);
for(j=0; j<theta->matrix_list[i]->rows; j++)
{
matrix_set(temp2, j, 0, 0.0);
}
free_matrix(theta_gradient_total->matrix_list[i]);
temp3 = matrix_scalar_multiply(temp2, lamda/m);
theta_gradient_total->matrix_list[i] = matrix_add(temp, temp3);
free_matrix(temp);
free_matrix(temp2);
free_matrix(temp3);
}
*gradient = roll_matrix_list(theta_gradient_total);
free_matrix_list(theta);
free_matrix_list(theta_gradient_total);
return 0.0;
}
ParticleIndexTriplets
InternalDynamicListTripletContainer::get_all_possible_indexes() const {
return get_indexes();
}
ParticleIndexPairsAdaptor::ParticleIndexPairsAdaptor(
const ParticlePairsTemp &ps)
: ParticleIndexPairs(get_indexes(ps)) {}
ParticleIndexesAdaptor::ParticleIndexesAdaptor(const ParticlesTemp &ps)
: tmp_(new ParticleIndexes(ps.size())), val_(tmp_.get()) {
*tmp_ = get_indexes(ps);
}
ParticleIndexesAdaptor::ParticleIndexesAdaptor(const Particles &ps)
: tmp_(new ParticleIndexes(ps.size())), val_(tmp_.get()) {
*tmp_ = get_indexes(ParticlesTemp(ps.begin(), ps.end()));
}
ParticleIndexPairs ConsecutivePairContainer::get_range_indexes() const {
return get_indexes();
}
