void Net::Train(const mxArray *mx_data, const mxArray *mx_labels) {
//mexPrintMsg("Start training...");
ReadData(mx_data);
ReadLabels(mx_labels);
InitNorm();
std::srand(params_.seed_);
size_t train_num = labels_.size1();
size_t numbatches = (size_t) ceil((ftype) train_num/params_.batchsize_);
trainerror_.resize(params_.numepochs_, numbatches);
for (size_t epoch = 0; epoch < params_.numepochs_; ++epoch) {
std::vector<size_t> randind(train_num);
for (size_t i = 0; i < train_num; ++i) {
randind[i] = i;
}
if (params_.shuffle_) {
std::random_shuffle(randind.begin(), randind.end());
}
std::vector<size_t>::const_iterator iter = randind.begin();
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = std::min(params_.batchsize_, (size_t)(randind.end() - iter));
std::vector<size_t> batch_ind = std::vector<size_t>(iter, iter + batchsize);
iter = iter + batchsize;
Mat data_batch = SubMat(data_, batch_ind, 1);
Mat labels_batch = SubMat(labels_, batch_ind, 1);
UpdateWeights(epoch, false);
InitActiv(data_batch);
Mat pred_batch;
Forward(pred_batch, 1);
InitDeriv(labels_batch, trainerror_(epoch, batch));
Backward();
CalcWeights();
UpdateWeights(epoch, true);
if (params_.verbose_ == 2) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1) +
std::string(", batch: ") + std::to_string(batch+1);
mexPrintMsg(info);
}
} // batch
if (params_.verbose_ == 1) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1);
mexPrintMsg(info);
}
} // epoch
//mexPrintMsg("Training finished");
}
HError(999,"Can only update linear transforms OR model parameters!");
xfInfo.useOutXForm = TRUE;
/* This initialises things - temporary hack - THINK!! */
CreateAdaptXForm(hset, "tmp");
}
/* initialise and pass information to the forward backward library */
InitialiseForBack(fbInfo, x, hset, uFlags, pruneInit, pruneInc,
pruneLim, minFrwdP);
if (parMode != 0) {
ConvLogWt(hset);
}
/* 2-model reestimation */
if (al_hmmUsed){
if (trace&T_TOP)
printf("2-model re-estimation enabled\n");
/* load alignment HMM set */
CreateHMMSet(&al_hset,&hmmStack,TRUE);
xfInfo.al_hset = &al_hset;
if (xfInfo.alXFormExt == NULL) xfInfo.alXFormExt = xfInfo.inXFormExt;
/* load multiple MMFs */
if (strlen(al_hmmMMF) > 0 ) {
char *p,*q;
Boolean eos;
p=q=al_hmmMMF;
for(;;) {
eos = (*p=='\0');
if ( ( isspace((int) *p) || *p == '\0' ) && (q!=p) ) {
/**
* Function that get two vectors, one for the entries and another to the outs, and train one epoch:
*/
int BKPNeuralNet::Train( int size, float *entry, int size2, float *out, float l_rate, float momentum )
{
/* Inserting the entries: */
if( SetEntry( size, entry ) == -1 )
return -1;
/* Getting the wrong out values: */
ActivAll();
/* Training the layer before the out layer: */
if( momentum != 0)
OutGradientMtm( out, size2, momentum );
else
OutGradient( out, size2 );
/* Training the net for each hidden layer: */
for( int i = _layers - 2; i > 0 ; i-- )
{
if( momentum != 0)
HiddenGradientMtm( i, momentum );
else
HiddenGradient( i );
}
/* Updating the weights: */
UpdateWeights( l_rate );
return 0;
}
void Net::Train(const mxArray *mx_data, const mxArray *mx_labels) {
//mexPrintMsg("Start training...");
ReadData(mx_data);
ReadLabels(mx_labels);
InitNorm();
size_t train_num = data_.size1();
size_t numbatches = DIVUP(train_num, params_.batchsize_);
trainerrors_.resize(params_.epochs_, 2);
trainerrors_.assign(0);
for (size_t epoch = 0; epoch < params_.epochs_; ++epoch) {
if (params_.shuffle_) {
Shuffle(data_, labels_);
}
StartTimer();
size_t offset = 0;
Mat data_batch, labels_batch, pred_batch;
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = MIN(train_num - offset, params_.batchsize_);
UpdateWeights(epoch, false);
data_batch.resize(batchsize, data_.size2());
labels_batch.resize(batchsize, labels_.size2());
SubSet(data_, data_batch, offset, true);
SubSet(labels_, labels_batch, offset, true);
ftype error1;
InitActiv(data_batch);
Forward(pred_batch, 1);
InitDeriv(labels_batch, error1);
trainerrors_(epoch, 0) += error1;
Backward();
UpdateWeights(epoch, true);
offset += batchsize;
if (params_.verbose_ == 2) {
mexPrintInt("Epoch", (int) epoch + 1);
mexPrintInt("Batch", (int) batch + 1);
}
} // batch
MeasureTime("totaltime");
if (params_.verbose_ == 1) {
mexPrintInt("Epoch", (int) epoch + 1);
}
} // epoch
trainerrors_ /= (ftype) numbatches;
//mexPrintMsg("Training finished");
}
/* EXPORT->MAPUpdateModels: update all models and save them in newDir if set,
new files have newExt if set */
void MAPUpdateModels(HMMSet *hset, UPDSet uFlags)
{
HMMScanState hss;
HLink hmm;
int px,nmapped=0,totM;
long n;
if (hset->logWt == TRUE) HError(999,"HMap: requires linear weights");
/* Intialise a few global variables */
SetVFloor( hset, vFloor, minVar);
maxM = MaxMixInSet(hset);
totM = TotMixInSet(hset);
S = hset->swidth[0];
if (hset->hsKind == TIEDHS){ /* TIEDHS - update mu & var once per HMMSet */
HError(999,"TIEDHS kind not currently supported in MAP estimation");
}
NewHMMScan(hset,&hss);
px=1;
do {
hmm = hss.hmm;
n = (long)hmm->hook;
if (n<minEgs && !(trace&T_UPD))
HError(-2331,"UpdateModels: %s[%d] copied: only %d egs\n",
HMMPhysName(hset,hmm),px,n);
if (n>=minEgs && n>0) {
if (uFlags & UPTRANS)
HError(999,"No support for MAP updating transition probabilities");
if (maxM>1 && uFlags & UPMIXES)
UpdateWeights(hset,px,hmm);
if (hset->hsKind != TIEDHS){
if (uFlags & UPVARS)
UpdateVars(hset,px,hmm);
if (uFlags & UPMEANS)
nmapped += UpdateMeans(hset,px,hmm);
if (uFlags & (UPMEANS|UPVARS))
FixGConsts(hmm);
}
}
px++;
} while (GoNextHMM(&hss));
EndHMMScan(&hss);
if (trace&T_TOP) {
printf("Observed components (means) %d of %d: %.2f\n",nmapped,totM,100*(float)nmapped/(float)totM);
if (nFloorVar > 0)
printf("Total %d floored variance elements in %d different mixes\n",
nFloorVar,nFloorVarMix);
fflush(stdout);
}
/* Reset vfloor */
ResetVFloor(hset,vFloor);
}
void AllocationMW::RunAllocationMW(int num_iterations) {
cout << "Running allocation LP MW algorithm \n";
for (int t = 1; t <= num_iterations; ++t) {
cout << "Entering iteration " << t << "\n";
// Get primal solution.
double t1, t2;
float diff;
t1 = omp_get_wtime();
global_problem_.ConstructPrimal(t);
t2 = omp_get_wtime();
diff = t2-t1;
cout << "execution time of relaxation computation was " << diff << "\n";
t1 = clock();
//Instance::UpdateAvgPrimal(t, solution_);
t2 = clock();
diff = ((float)t2-(float)t1);
cout << "execution time of average primal update was " << diff << "\n";
// Runs CPLEX for debugging only, should be turned off.
// VerifySolution();
// Calculate slacks, update averages and recalculate weights.
t1 = omp_get_wtime();
CalculateSlacks();
UpdateAvgSlacks(t);
t2 = omp_get_wtime();
diff = t2-t1;
cout << "execution time of slack update was " << diff << "\n";
// Calculate slacks, update averages and recalculate weights.
t1 = omp_get_wtime();
ReportWorstInfeasibility(t);
t2 = omp_get_wtime();
diff = t2-t1;
cout << "execution time of worst infeasibility update was " << diff << "\n";
// Calculate slacks, update averages and recalculate weights.
t1 = clock();
UpdateWeights();
t2 = clock();
diff = ((float)t2-(float)t1);
cout << "execution time of weight update was " << diff << "\n";
t1 = omp_get_wtime();
UpdateGlobalProblem();
t2 = omp_get_wtime();
diff = t2-t1;
cout << "execution time of global problem update was " << diff << "\n";
ReportWeightStats();
}
}
/* UpdateModels: update all models and save them in newDir if set,
new files have newExt if set */
void UpdateModels(void)
{
int n;
HLink hmm;
HMMScanState hss;
if (trace&T_INT){
printf("Starting Model Update\n"); fflush(stdout);
}
if (hsKind==TIEDHS){
if (uFlags & UPVARS) /* TIEDHS therefore only done once per HMMSet */
UpdateTMVars();
if (uFlags & UPMEANS)
UpdateTMMeans();
if (uFlags & (UPMEANS|UPVARS))
FixAllGConsts(&hset);
}
NewHMMScan(&hset,&hss);
do {
hmm = hss.hmm;
n = (int)hmm->hook;
if (n<minEgs && !(trace&T_OPT))
HError(-2428,"%s copied: only %d egs\n",HMMPhysName(&hset,hmm),n);
if (n>=minEgs) {
if (uFlags & UPTRANS)
UpdateTrans(hmm);
if (maxMixes>1 && uFlags & UPMIXES)
UpdateWeights(hmm);
}
if (trace&T_OPT) {
if (n<minEgs)
printf("Model %s copied: only %d examples\n",
HMMPhysName(&hset,hmm),n);
else
printf("Model %s updated with %d examples\n",
HMMPhysName(&hset,hmm),n);
fflush(stdout);
}
} while (GoNextHMM(&hss));
EndHMMScan(&hss);
if (trace&T_TOP){
printf("Saving hmm's to dir %s\n",(newDir==NULL)?"Current":newDir);
fflush(stdout);
}
if(SaveHMMSet(&hset,newDir,newExt,NULL,saveBinary)<SUCCESS)
HError(2411,"UpdateModels: SaveHMMSet failed");
ResetHeaps(); /* Clean Up */
if (trace&T_TOP)
printf("Reestimation complete - average log prob per frame = %e\n",
totalPr/(double)totalT);
}
/**
* Function that get two vectors, one for the entries and another to the outs, and train one epoch:
*/
int Train( PtNet Net, int size, float *entry, int size2, float *out, float l_rate )
{
int Ret;
/* Inserting the entries: */
Ret = SetEntry( Net, size, entry);
/* Getting the wrong out values: */
ActivAll(Net);
/* Training one epoch: */
Ret = TrainOneEpoch( Net, out, size2 );
/* Updating the weights: */
UpdateWeights( Net, l_rate );
return Ret;
}
void Instance::RunMultiplicativeWeights(long double num_iterations, long double numerical_accuracy_tolerance) {
SetBudgets(0.25);
CalculateInstanceWidth();
BuildPrimals();
//ComputeCPLEXRevenue();
bool mw_algorithm = false;
if (mw_algorithm) {
CreateGlobalProblem();
global_problem_.InitializeBudgetAllocation();
for (int t = 1; t <= num_iterations; ++t) {
cout << "Entering iteration ";
cout << t;
cout << "\n";
// Get primal solution.
global_problem_.ConstructPrimal(primal_sol_, t);
// VerifySolution();
// Calculate slacks, update averages and recalculate weights.
cout << "Running MW update \n";
CalculateSlacks();
UpdateAvgPrimal(t);
UpdateAvgSlacks(t);
ReportWorstInfeasibility(t);
UpdateWeights();
UpdateGlobalProblem();
ReportWeightStats();
}
} else {
NaiveMW naive_mw = NaiveMW(num_impressions_, num_advertisers_, max_bid_, epsilon_, width_, bid_sparsity_,
budgets_);
naive_mw.RunNaiveMW(&bids_matrix_, primal_sol_, &avg_primal_sol_);
}
}
void Net::Train(const mxArray *mx_data, const mxArray *mx_labels) {
//mexPrintMsg("Start training...");
LayerFull *lastlayer = static_cast<LayerFull*>(layers_.back());
std::vector<size_t> labels_dim = mexGetDimensions(mx_labels);
mexAssert(labels_dim.size() == 2, "The label array must have 2 dimensions");
mexAssert(labels_dim[0] == lastlayer->length_,
"Labels and last layer must have equal number of classes");
size_t train_num = labels_dim[1];
Mat labels(labels_dim);
mexGetMatrix(mx_labels, labels);
classcoefs_.assign(labels_dim[0], 1);
if (params_.balance_) {
Mat labels_mean(labels_dim[0], 1);
labels.Mean(2, labels_mean);
for (size_t i = 0; i < labels_dim[0]; ++i) {
mexAssert(labels_mean(i) > 0, "Balancing impossible: one of the classes is not presented");
(classcoefs_[i] /= labels_mean(i)) /= labels_dim[0];
}
}
if (lastlayer->function_ == "SVM") {
(labels *= 2) -= 1;
}
size_t mapnum = 1;
if (mexIsCell(mx_data)) {
mapnum = mexGetNumel(mx_data);
}
mexAssert(mapnum == layers_.front()->outputmaps_,
"Data must have the same number of cells as outputmaps on the first layer");
std::vector< std::vector<Mat> > data(mapnum);
for (size_t map = 0; map < mapnum; ++map) {
const mxArray *mx_cell;
if (mexIsCell(mx_data)) {
mx_cell = mxGetCell(mx_data, map);
} else {
mx_cell = mx_data;
}
std::vector<size_t> data_dim = mexGetDimensions(mx_cell);
mexAssert(data_dim.size() == 3, "The data array must have 3 dimensions");
mexAssert(data_dim[0] == layers_.front()->mapsize_[0] &&
data_dim[1] == layers_.front()->mapsize_[1],
"Data and the first layer must have equal sizes");
mexAssert(data_dim[2] == train_num, "All data maps and labels must have equal number of objects");
mexGetMatrix3D(mx_cell, data[map]);
}
size_t numbatches = ceil((double) train_num/params_.batchsize_);
trainerror_.assign(params_.numepochs_ * numbatches, 0);
for (size_t epoch = 0; epoch < params_.numepochs_; ++epoch) {
std::vector<size_t> randind(train_num);
for (size_t i = 0; i < train_num; ++i) {
randind[i] = i;
}
if (params_.shuffle_) {
std::random_shuffle(randind.begin(), randind.end());
}
std::vector<size_t>::const_iterator iter = randind.begin();
for (size_t batch = 0; batch < numbatches; ++batch) {
size_t batchsize = std::min(params_.batchsize_, (size_t)(randind.end() - iter));
std::vector<size_t> batch_ind = std::vector<size_t>(iter, iter + batchsize);
iter = iter + batchsize;
std::vector< std::vector<Mat> > data_batch(mapnum);
for (size_t map = 0; map < mapnum; ++map) {
data_batch[map].resize(batchsize);
for (size_t i = 0; i < batchsize; ++i) {
data_batch[map][i] = data[map][batch_ind[i]];
}
}
Mat labels_batch(labels_dim[0], batchsize);
Mat pred_batch(labels_dim[0], batchsize);
labels.SubMat(batch_ind, 2 ,labels_batch);
UpdateWeights(false);
Forward(data_batch, pred_batch, true);
Backward(labels_batch, trainerror_[epoch * numbatches + batch]);
UpdateWeights(true);
if (params_.verbose_ == 2) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1) +
std::string(", batch: ") + std::to_string(batch+1);
mexPrintMsg(info);
}
} // batch
if (params_.verbose_ == 1) {
std::string info = std::string("Epoch: ") + std::to_string(epoch+1);
mexPrintMsg(info);
}
} // epoch
//mexPrintMsg("Training finished");
}
void MLP::UpdateMiniBatch(const std::vector<TrainingSample> &training_sample_set_with_bias,
double learning_rate,
int max_iterations,
double min_error_cost) {
int num_examples = training_sample_set_with_bias.size();
int num_features = training_sample_set_with_bias[0].GetInputVectorSize();
//{
// int layer_i = -1;
// int node_i = -1;
// std::cout << "Starting weights:" << std::endl;
// for (const auto & layer : m_layers) {
// layer_i++;
// node_i = -1;
// std::cout << "Layer " << layer_i << " :" << std::endl;
// for (const auto & node : layer.GetNodes()) {
// node_i++;
// std::cout << "\tNode " << node_i << " :\t";
// for (auto m_weightselement : node.GetWeights()) {
// std::cout << m_weightselement << "\t";
// }
// std::cout << std::endl;
// }
// }
//}
size_t i = 0;
double current_iteration_cost_function = 0.0;
for (i = 0; i < max_iterations; i++) {
current_iteration_cost_function = 0.0;
for (auto & training_sample_with_bias : training_sample_set_with_bias) {
std::vector<double> predicted_output;
std::vector< std::vector<double> > all_layers_activations;
GetOutput(training_sample_with_bias.input_vector(),
&predicted_output,
&all_layers_activations);
const std::vector<double> & correct_output =
training_sample_with_bias.output_vector();
assert(correct_output.size() == predicted_output.size());
std::vector<double> deriv_error_output(predicted_output.size());
if ((i % (max_iterations / 100)) == 0) {
std::stringstream temp_training;
temp_training << training_sample_with_bias << "\t\t";
temp_training << "Predicted output: [";
for (int i = 0; i < predicted_output.size(); i++) {
if (i != 0)
temp_training << ", ";
temp_training << predicted_output[i];
}
temp_training << "]";
LOG(INFO) << temp_training.str();
}
for (int j = 0; j < predicted_output.size(); j++) {
current_iteration_cost_function +=
(std::pow)((correct_output[j] - predicted_output[j]), 2);
deriv_error_output[j] =
-2 * (correct_output[j] - predicted_output[j]);
}
UpdateWeights(all_layers_activations,
deriv_error_output,
learning_rate);
}
if ((i % (max_iterations / 100)) == 0)
LOG(INFO) << "Iteration " << i << " cost function f(error): "
<< current_iteration_cost_function;
if (current_iteration_cost_function < min_error_cost)
break;
}
LOG(INFO) << "Iteration " << i << " cost function f(error): "
<< current_iteration_cost_function;
LOG(INFO) << "******************************";
LOG(INFO) << "******* TRAINING ENDED *******";
LOG(INFO) << "******* " << i << " iters *******";
LOG(INFO) << "******************************";
//{
// int layer_i = -1;
// int node_i = -1;
// std::cout << "Final weights:" << std::endl;
// for (const auto & layer : m_layers) {
// layer_i++;
// node_i = -1;
// std::cout << "Layer " << layer_i << " :" << std::endl;
// for (const auto & node : layer.GetNodes()) {
// node_i++;
// std::cout << "\tNode " << node_i << " :\t";
// for (auto m_weightselement : node.GetWeights()) {
// std::cout << m_weightselement << "\t";
// }
// std::cout << std::endl;
// }
// }
//}
};
extern int ExpandedEnsembleDynamics(FILE *log, t_inputrec *ir, gmx_enerdata_t *enerd,
t_state *state, t_extmass *MassQ, int fep_state, df_history_t *dfhist,
gmx_int64_t step,
rvec *v, t_mdatoms *mdatoms)
/* Note that the state variable is only needed for simulated tempering, not
Hamiltonian expanded ensemble. May be able to remove it after integrator refactoring. */
{
real *pfep_lamee, *scaled_lamee, *weighted_lamee;
double *p_k;
int i, nlim, lamnew, totalsamples;
real oneovert, maxscaled = 0, maxweighted = 0;
t_expanded *expand;
t_simtemp *simtemp;
gmx_bool bIfReset, bSwitchtoOneOverT, bDoneEquilibrating = FALSE;
expand = ir->expandedvals;
simtemp = ir->simtempvals;
nlim = ir->fepvals->n_lambda;
snew(scaled_lamee, nlim);
snew(weighted_lamee, nlim);
snew(pfep_lamee, nlim);
snew(p_k, nlim);
/* update the count at the current lambda*/
dfhist->n_at_lam[fep_state]++;
/* need to calculate the PV term somewhere, but not needed here? Not until there's a lambda state that's
pressure controlled.*/
/*
pVTerm = 0;
where does this PV term go?
for (i=0;i<nlim;i++)
{
fep_lamee[i] += pVTerm;
}
*/
/* determine the minimum value to avoid overflow. Probably a better way to do this */
/* we don't need to include the pressure term, since the volume is the same between the two.
is there some term we are neglecting, however? */
if (ir->efep != efepNO)
{
for (i = 0; i < nlim; i++)
{
if (ir->bSimTemp)
{
/* Note -- this assumes no mass changes, since kinetic energy is not added . . . */
scaled_lamee[i] = (enerd->enerpart_lambda[i+1]-enerd->enerpart_lambda[0])/(simtemp->temperatures[i]*BOLTZ)
+ enerd->term[F_EPOT]*(1.0/(simtemp->temperatures[i])- 1.0/(simtemp->temperatures[fep_state]))/BOLTZ;
}
else
{
scaled_lamee[i] = (enerd->enerpart_lambda[i+1]-enerd->enerpart_lambda[0])/(expand->mc_temp*BOLTZ);
/* mc_temp is currently set to the system reft unless otherwise defined */
}
/* save these energies for printing, so they don't get overwritten by the next step */
/* they aren't overwritten in the non-free energy case, but we always print with these
for simplicity */
}
}
else
{
if (ir->bSimTemp)
{
for (i = 0; i < nlim; i++)
{
scaled_lamee[i] = enerd->term[F_EPOT]*(1.0/simtemp->temperatures[i] - 1.0/simtemp->temperatures[fep_state])/BOLTZ;
}
}
}
for (i = 0; i < nlim; i++)
{
pfep_lamee[i] = scaled_lamee[i];
weighted_lamee[i] = dfhist->sum_weights[i] - scaled_lamee[i];
if (i == 0)
{
maxscaled = scaled_lamee[i];
maxweighted = weighted_lamee[i];
}
else
{
if (scaled_lamee[i] > maxscaled)
{
maxscaled = scaled_lamee[i];
}
if (weighted_lamee[i] > maxweighted)
{
maxweighted = weighted_lamee[i];
}
}
}
for (i = 0; i < nlim; i++)
{
scaled_lamee[i] -= maxscaled;
weighted_lamee[i] -= maxweighted;
}
/* update weights - we decide whether or not to actually do this inside */
bDoneEquilibrating = UpdateWeights(nlim, expand, dfhist, fep_state, scaled_lamee, weighted_lamee, step);
if (bDoneEquilibrating)
{
if (log)
{
fprintf(log, "\nStep %d: Weights have equilibrated, using criteria: %s\n", (int)step, elmceq_names[expand->elmceq]);
}
}
lamnew = ChooseNewLambda(nlim, expand, dfhist, fep_state, weighted_lamee, p_k,
ir->expandedvals->lmc_seed, step);
/* if using simulated tempering, we need to adjust the temperatures */
if (ir->bSimTemp && (lamnew != fep_state)) /* only need to change the temperatures if we change the state */
{
int i, j, n, d;
real *buf_ngtc;
real told;
int nstart, nend, gt;
snew(buf_ngtc, ir->opts.ngtc);
for (i = 0; i < ir->opts.ngtc; i++)
{
if (ir->opts.ref_t[i] > 0)
{
told = ir->opts.ref_t[i];
ir->opts.ref_t[i] = simtemp->temperatures[lamnew];
buf_ngtc[i] = std::sqrt(ir->opts.ref_t[i]/told); /* using the buffer as temperature scaling */
}
}
/* we don't need to manipulate the ekind information, as it isn't due to be reset until the next step anyway */
nstart = 0;
nend = mdatoms->homenr;
for (n = nstart; n < nend; n++)
{
gt = 0;
if (mdatoms->cTC)
{
gt = mdatoms->cTC[n];
}
for (d = 0; d < DIM; d++)
{
v[n][d] *= buf_ngtc[gt];
}
}
if (inputrecNptTrotter(ir) || inputrecNphTrotter(ir) || inputrecNvtTrotter(ir))
{
/* we need to recalculate the masses if the temperature has changed */
init_npt_masses(ir, state, MassQ, FALSE);
for (i = 0; i < state->nnhpres; i++)
{
for (j = 0; j < ir->opts.nhchainlength; j++)
{
state->nhpres_vxi[i+j] *= buf_ngtc[i];
}
}
for (i = 0; i < ir->opts.ngtc; i++)
{
for (j = 0; j < ir->opts.nhchainlength; j++)
{
state->nosehoover_vxi[i+j] *= buf_ngtc[i];
}
}
}
sfree(buf_ngtc);
}
/* now check on the Wang-Landau updating critera */
if (EWL(expand->elamstats))
{
bSwitchtoOneOverT = FALSE;
if (expand->bWLoneovert)
{
totalsamples = 0;
for (i = 0; i < nlim; i++)
{
totalsamples += dfhist->n_at_lam[i];
}
oneovert = (1.0*nlim)/totalsamples;
/* oneovert has decreasd by a bit since last time, so we actually make sure its within one of this number */
/* switch to 1/t incrementing when wl_delta has decreased at least once, and wl_delta is now less than 1/t */
if ((dfhist->wl_delta <= ((totalsamples)/(totalsamples-1.00001))*oneovert) &&
(dfhist->wl_delta < expand->init_wl_delta))
{
bSwitchtoOneOverT = TRUE;
}
}
if (bSwitchtoOneOverT)
{
dfhist->wl_delta = oneovert; /* now we reduce by this each time, instead of only at flatness */
}
else
{
bIfReset = CheckHistogramRatios(nlim, dfhist->wl_histo, expand->wl_ratio);
if (bIfReset)
{
for (i = 0; i < nlim; i++)
{
dfhist->wl_histo[i] = 0;
}
dfhist->wl_delta *= expand->wl_scale;
if (log)
{
fprintf(log, "\nStep %d: weights are now:", (int)step);
for (i = 0; i < nlim; i++)
{
fprintf(log, " %.5f", dfhist->sum_weights[i]);
}
fprintf(log, "\n");
}
}
}
}
sfree(pfep_lamee);
sfree(scaled_lamee);
sfree(weighted_lamee);
sfree(p_k);
return lamnew;
}
void Reaching::ReachingStep(float dt){
if(dt<EPSILON) return;//no point of doing anything
// cout<<"DT "<<dt<<endl;
joint_vec_t tmp1,tmp3; // temporary variables
cart_vec_t tmp13;
float dist=0;
// dt = dt/10;
//dist = UpdateLocalTarget();
if(dist>tol || isnan(dist)){
SetLocalTarget(target);
cout<<dist<<" "<<tol<<endl;
}
// vite in angle space and cart space
alpha*=dt;beta*=dt;
ViteAngle(tar_angle,pos_angle,v_angle,des_angle,des_v_angle);
ViteCart(target,pos_cart,v_cart,des_cart,des_v_cart);
alpha /= dt; beta/=dt;
// cout<<"vite done"<<endl;
#ifdef OBSTACLE_AVOIDANCE
// find the closest obstacle
float ro,point;
float gamma;
CMatrix4_t ijac;
v4_clear(des_a_angle_obs);
if(env){
for (i=1;i<3;i++){
for(int j=0;j<env->CountManipulableObjects();j++){
LinkDistanceToObject(i,env->GetObject(j),&ro,&point,tmp13);
// coutvec(tmp13);
IntermediateJacobian(i,point,pos_angle,ijac);
m3_4_t_v_multiply(ijac,tmp13,tmp1);
// eq. 18 of Khatib,icra'85
if(ro<=obstacle_rad){
gamma = nu *(1/ro -1/obstacle_rad)/(ro*ro); //(ro*ro)
//test
// gamma *= -v4_dot(tmp1,v_angle)/50;
// gamma = max(0.0,gamma);
}
else{
gamma =0;
}
v4_scale(tmp1,gamma,tmp1);
v4_add(des_a_angle_obs,tmp1,des_a_angle_obs);
}
}
v4_add(des_a_angle_obs,des_v_angle,des_v_angle);
v4_add(pos_angle,des_v_angle,des_angle);
}
#endif
body->SetAnglesInRange(des_angle);
des_v_angle = des_angle - pos_angle;
des_v_cart = des_cart - pos_cart;
if(pure_joint_ctl){
tmp1 = des_angle;
}
else{
UpdateWeights();
// coherence enforcement
ProjectVector(des_v_cart,des_v_angle,tmp3);
tmp1 = pos_angle+tmp3;
}
body->SetAnglesInRange(tmp1);
body->Angle2Cart(tmp1,tmp13);
v_angle = tmp1 - pos_angle;
v_cart = tmp13 - pos_cart;
pos_cart = tmp13;
pos_angle = tmp1;
//pos_angle.Print();
//pos_cart.Print();
}