/* Process command line parameters:
argv[1]: Name of data file or '-' for stdin
argv[2]: Number of changepoints
argv[3]: Number of iterations
argv[4]: seed for random number generator
argv[5]: (optional) Prefix for output files
*/
void getFixedArgs(int argc, char **argv) {
char* endptr;
const char* usage="icmcstatFixed FILE NK ITERATIONS SEED [OUTPUTPREFIX]";
double alpha=1, beta=1;
if(argc<5) fprintf(ERR, "%s\n", usage), exit(1);
dataFn=argv[1];
printf("Reading data from ");
if(!strcmp(dataFn, "-")) printf("stdin\n");
else printf("%s\n", dataFn);
printf("%s nK\n", argv[2]);
nK = strtol(argv[2], &endptr, 10);
nProb=nK+1;
printf("%s iterations\n", argv[3]);
nIter = strtol(argv[3], &endptr, 10);
seed = strtol(argv[4], &endptr, 10);
printf("Seed for random number generator: %i\n", seed);
/* Optional parameter*/
if(argc==6) {
prefix=argv[5];
printf("Prefix prepended to output files: %s\n", prefix);
}
fprintf(ERR, "Setting alpha=%g, beta=%g\n", alpha, beta);
setAlpha(alpha); setBeta(beta);
}
bool Pareto::setSlotBeta(const Number* const x)
{
bool ok = false;
if(x != nullptr)
ok = setBeta(x->getDouble());
return ok;
}
FrechetDistribution::FrechetDistribution(double alpha, double beta)
: UncertaintyDescription(boost::shared_ptr<detail::UncertaintyDescription_Impl>(
new detail::UncertaintyDescription_Impl(FrechetDistribution::type())))
{
setAlpha(alpha);
setBeta(beta);
}
GumbelDistribution::GumbelDistribution(double alpha, double beta)
: UncertaintyDescription(std::shared_ptr<detail::UncertaintyDescription_Impl>(
new detail::UncertaintyDescription_Impl(GumbelDistribution::type())))
{
setAlpha(alpha);
setBeta(beta);
}
void ChainArray::initialise(uint id, const Eigen::VectorXd& sample,
double energy, double sigma, double beta)
{
setSigma(id, sigma);
setBeta(id, beta);
cache_[id].push_back({ sample, energy, sigma_[id], beta_[id], true, SwapType::NoAttempt});
lastState_[id] = cache_[id].back();
}
Eigen::MatrixXd GLMMBelief::evaluateSecondDerivative(const Eigen::VectorXd& x,
const Parameters& parameters)
{
setTheta(parameters.GLMMTheta);
setBeta(parameters.GLMMBeta);
auto family = parameters.GLMMFamily;
auto linearPredictor = computeLinearPredictor(x);
return LambdatThetaZt_ * family.evaluateSecondDerivative(linearPredictor, response_, weights_).matrix().asDiagonal() * LambdatThetaZt_.transpose();
}
double GLMMBelief::evaluate(const Eigen::VectorXd& x,
const Parameters& parameters)
{
setTheta(parameters.GLMMTheta);
setBeta(parameters.GLMMBeta);
auto family = parameters.GLMMFamily;
auto linearPredictor = computeLinearPredictor(x);
return family.evaluate(linearPredictor, response_, weights_);
}
BetaDistribution::BetaDistribution(double alpha, double beta, double lowerBound, double upperBound)
: UncertaintyDescription(boost::shared_ptr<detail::UncertaintyDescription_Impl>(
new detail::UncertaintyDescription_Impl(BetaDistribution::type())))
{
setAlpha(alpha);
setBeta(beta);
setLowerBound(lowerBound);
setUpperBound(upperBound);
}
InteractinSimpleGaussian::InteractinSimpleGaussian(System *system, double alpha, double beta) :
WaveFunction(system)
{
assert(alpha >= 0);
m_numberOfParameters = 2;
m_parameters.reserve(2);
m_parameters.push_back(alpha);
m_parameters.push_back(beta);
setAlpha(alpha);
setAlpha2(alpha*alpha);
setBeta(beta);
}
AdaptiveSO2CPGSynPlas::AdaptiveSO2CPGSynPlas(Neuron* perturbingNeuron)
: ExtendedSO2CPG(perturbingNeuron){
setAlpha(1.01);
setPhi(0.3);
setMu(1.00);
setGamma(0.02);
setEpsilon(0.03);
setBeta(0.00);
// for a range of P from -1 to 1
setBetaDynamics (-1.0, 0.003, 0.0000);
setGammaDynamics (-1.0, 0.003, 1.0000);
setEpsilonDynamics(0.04, 0.003, 0.0001);
}
void AdaptiveSO2CPGSynPlas::updateWeights() {
const double& phi = getPhi();
const double& beta = getBeta();
const double& gamma = getGamma();
const double& epsilon = getEpsilon();
const double& mu = getMu();
const double& F = getOutput(2);
const double& w01 = getWeight(0,1);
const double& x = getOutput(0);
const double& y = getOutput(1);
const double& P = getPerturbation();
// general approach
setPhi ( phi + mu * gamma * F * w01 * y );
setBeta ( beta + betaHebbRate * x * F - betaDecayRate * (beta - betaZero) );
setGamma ( gamma + gammaHebbRate * x * F - gammaDecayRate * (gamma - gammaZero) );
setEpsilon( epsilon + epsilonHebbRate * F * P - epsilonDecayRate * (epsilon - epsilonZero) );
}
/* Process command line parameters:
argv[1]: Name of data file or '-' for stdin
argv[2]: Number of iterations
argv[3]: seed for random number generator
argv[4]: (optional) Prefix for output files
argv[5]: (optional) For RESTART: Initial changepoint locations
argv[6]: (optional) For RESTART: Initial success probabilities
*/
void getArgs(int argc, char **argv) {
const int nArgs=4;
const int nOpt=3;
char* endptr;
const char* usage="icmcstat FILE ITERATIONS SEED [OUTPUTPREFIX] [K0FILE] [P0FILE]";
double alpha=1, beta=1;
if( (argc<nArgs)|| (argc>nArgs+nOpt)) fprintf(ERR, "%s\n", usage), exit(1);
dataFn=argv[1];
printf("Reading data from ");
if(!strcmp(dataFn, "-")) printf("stdin\n");
else printf("%s\n", dataFn);
printf("%s iterations\n", argv[2]);
nIter = strtol(argv[2], &endptr, 10);
seed = strtol(argv[3], &endptr, 10);
printf("Seed for random number generator: %i\n", seed);
/* Optional parameters:*/
/* Prefix */
if(argc>=nArgs+1) {
prefix=argv[4];
printf("Prefix prepended to output files: %s\n", prefix);
}
/* Restart */
if(argc==nArgs+nOpt) {
restart=1;
re_K=argv[5];
re_P=argv[6];
printf("Restarting with parameters from:\n\t%s\n\t%s\n", re_K, re_P);
}
fprintf(ERR, "Setting alpha=%g, beta=%g\n", alpha, beta);
setAlpha(alpha); setBeta(beta);
}
ExponentialDistribution::ExponentialDistribution(double beta)
: UncertaintyDescription(std::shared_ptr<detail::UncertaintyDescription_Impl>(
new detail::UncertaintyDescription_Impl(ExponentialDistribution::type())))
{
setBeta(beta);
}
void CyclicCoordinateDescent::kktSwindle(const ModeFindingArguments& arguments) {
const auto maxIterations = arguments.maxIterations;
const auto convergenceType = arguments.convergenceType;
const auto epsilon = arguments.tolerance;
// Make sure internal state is up-to-date
checkAllLazyFlags();
std::list<ScoreTuple> activeSet;
std::list<ScoreTuple> inactiveSet;
std::list<int> excludeSet;
// Initialize sets
int intercept = -1;
if (hXI.getHasInterceptCovariate()) {
intercept = hXI.getHasOffsetCovariate() ? 1 : 0;
}
for (int index = 0; index < J; ++index) {
if (fixBeta[index]) {
excludeSet.push_back(index);
} else {
if (index == intercept || // Always place intercept into active set
!jointPrior->getSupportsKktSwindle(index)) {
// activeSet.push_back(index);
activeSet.push_back(std::make_tuple(index, 0.0, true));
} else {
inactiveSet.push_back(std::make_tuple(index, 0.0, false));
}
}
}
bool done = false;
int swindleIterationCount = 1;
// int initialActiveSize = activeSet.size();
int perPassSize = arguments.swindleMultipler;
while (!done) {
if (noiseLevel >= QUIET) {
std::ostringstream stream;
stream << "\nKKT Swindle count " << swindleIterationCount << ", activeSet size = " << activeSet.size();
logger->writeLine(stream);
}
// Enforce all beta[inactiveSet] = 0
for (auto& inactive : inactiveSet) {
if (getBeta(std::get<0>(inactive)) != 0.0) { // Touch only if necessary
setBeta(std::get<0>(inactive), 0.0);
}
}
double updateTime = 0.0;
lastReturnFlag = SUCCESS;
if (activeSet.size() > 0) { // find initial mode
auto start = bsccs::chrono::steady_clock::now();
findMode(begin(activeSet), end(activeSet), maxIterations, convergenceType, epsilon);
auto end = bsccs::chrono::steady_clock::now();
bsccs::chrono::duration<double> elapsed_seconds = end-start;
updateTime = elapsed_seconds.count();
}
if (noiseLevel >= QUIET) {
std::ostringstream stream;
stream << "update time: " << updateTime << " in " << lastIterationCount << " iterations.";
logger->writeLine(stream);
}
if (inactiveSet.size() == 0 || lastReturnFlag != SUCCESS) { // Computed global mode, nothing more to do, or failed
done = true;
} else { // still inactive covariates
if (swindleIterationCount == maxIterations) {
lastReturnFlag = MAX_ITERATIONS;
done = true;
if (noiseLevel > SILENT) {
std::ostringstream stream;
stream << "Reached maximum swindle iterations";
logger->writeLine(stream);
}
} else {
auto checkConditions = [this] (const ScoreTuple& score) {
return (std::get<1>(score) <= jointPrior->getKktBoundary(std::get<0>(score)));
};
// auto checkAlmostConditions = [this] (const ScoreTuple& score) {
// return (std::get<1>(score) < 0.9 * jointPrior->getKktBoundary(std::get<0>(score)));
// };
// Check KKT conditions
computeKktConditions(inactiveSet);
bool satisfied = std::all_of(begin(inactiveSet), end(inactiveSet), checkConditions);
if (satisfied) {
done = true;
} else {
// auto newActiveSize = initialActiveSize + perPassSize;
auto count1 = std::distance(begin(inactiveSet), end(inactiveSet));
auto count2 = std::count_if(begin(inactiveSet), end(inactiveSet), checkConditions);
// Remove elements from activeSet if less than 90% of boundary
// computeKktConditions(activeSet); // TODO Already computed in findMode
//
// // for (auto& active : activeSet) {
// // std::ostringstream stream;
// // stream << "Active: " << std::get<0>(active) << " : " << std::get<1>(active) << " : " << std::get<2>(active);
// // logger->writeLine(stream);
// // }
//
// int countActiveViolations = 0;
// while(activeSet.size() > 0 &&
// checkAlmostConditions(activeSet.back())
// ) {
// auto& back = activeSet.back();
//
// // std::ostringstream stream;
// // stream << "Remove: " << std::get<0>(back) << ":" << std::get<1>(back)
// // << " cut @ " << jointPrior->getKktBoundary(std::get<0>(back))
// // << " diff = " << (std::get<1>(back) - jointPrior->getKktBoundary(std::get<0>(back)));
// // logger->writeLine(stream);
//
// inactiveSet.push_back(back);
// activeSet.pop_back();
// ++countActiveViolations;
// }
// end
// Move inactive elements into active if KKT conditions are not met
while (inactiveSet.size() > 0
&& !checkConditions(inactiveSet.front())
// && activeSet.size() < newActiveSize
) {
auto& front = inactiveSet.front();
// std::ostringstream stream;
// stream << std::get<0>(front) << ":" << std::get<1>(front);
// logger->writeLine(stream);
activeSet.push_back(front);
inactiveSet.pop_front();
}
if (noiseLevel >= QUIET) {
std::ostringstream stream;
// stream << " Active set violations: " << countActiveViolations << std::endl;
stream << "Inactive set violations: " << (count1 - count2);
logger->writeLine(stream);
}
}
}
}
++swindleIterationCount;
perPassSize *= 2;
logger->yield(); // This is not re-entrant safe
}
// restore fixBeta
std::fill(fixBeta.begin(), fixBeta.end(), false);
for (auto index : excludeSet) {
fixBeta[index] = true;
}
}
