void VideoContentReveal::setup ( string _path , ofRectangle _bounds )
{
path = ofToDataPath( _path ) ;
video.loadMovie ( _path ) ;
video.setAnchorPercent( 0.5 , 0.5 ) ;
video.setLoopState( OF_LOOP_NONE ) ;
if ( _path == "/videos/AboutAll.mov" )
video.setSpeed( 1.25f ) ;
// cout << "video speed is: " << video.getSpeed() << endl ;
cout << "attemping to load path" << path << endl ;
// bool result = video.loadMovie( ofToDataPath( path ) ) ;
// cout << " result : " << result << endl ;
//scale = 1 / ((float)video.width / (float) _bounds.width) ;
scale = 1.0f ;
// cout << "scale : " << scale << " | 1/ ( " << video.getWidth() << " / " << _bounds.width << " )" << endl ;
// cout << "heights : " << video.getHeight() << " , " << video.height << endl ;
// float newHeight = (float)video.getHeight() * scale ;
// float newWidth = (float)video.getWidth() * scale ;
//bounds = ofRectangle( _bounds.width , _bounds.height ,newWidth , newHeight ) ;
//bounds = ofRectangle( 125 , newHeight * -.65 ,newWidth , newHeight ) ;
initialValues() ;
maxScale = 1.0f ;
//In here for Debug
//video.setVolume(0.0f ) ;
}
void BanditSingleSparseStump::init() {
const int numClasses = _pTrainingData->getNumClasses();
const int numColumns = _pTrainingData->getNumAttributes();
const int armNumber = _banditAlgo->getArmNumber();
if ( numColumns < armNumber )
{
cerr << "The number of colums smaller than the number of the arms!!!!!!" << endl;
exit( -1 );
}
BaseLearner* pWeakHypothesisSource =
BaseLearner::RegisteredLearners().getLearner("SingleSparseStumpLearner");
_banditAlgo->setArmNumber( numColumns );
vector<AlphaReal> initialValues( numColumns );
for( int i=0; i < numColumns; i++ )
{
SingleSparseStumpLearner* singleStump = dynamic_cast<SingleSparseStumpLearner*>( pWeakHypothesisSource->create());
singleStump->setTrainingData(_pTrainingData);
AlphaReal energy = singleStump->run( i );
AlphaReal edge = singleStump->getEdge();
AlphaReal reward = getRewardFromEdge( (AlphaReal) edge );
initialValues[i] = reward;
delete singleStump;
}
_banditAlgo->initialize( initialValues );
}
void ImageContent::transitionIn ( float time , float delay )
{
initialValues() ;
Tweenzor::add( &scale , scale , maxScale , delay , time, EASE_OUT_QUAD ) ;
Tweenzor::add( &alpha , alpha , 1.0f , delay , time , EASE_OUT_QUAD ) ;
}
void VideoContentReveal::transitionIn ( float time , float delay )
{
initialValues() ;
video.play() ;
video.update() ;
video.stop() ;
Tweenzor::add( &alpha , alpha , 1.0f , delay , time , EASE_OUT_QUAD ) ;
Tweenzor::add( &scale , scale , maxScale , delay , time , EASE_OUT_QUAD ) ;
Tweenzor::addCompleteListener( Tweenzor::getTween( &alpha ) , this , &VideoContentReveal::transitionInComplete ) ;
//Tweenzor::addCompleteListener( Tweenzor::getTween( &alpha ) , this , VideoContent::transitionInComplete ) ;
// Tweenzor::add( &playImage.alpha , playImage.alpha , 1.0f , delay , time , EASE_OUT_QUAD ) ;
}
int main(int argc, char ** argv) {
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", NULL);
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"space_", 1, NULL);
QUESO::GslVector minBound(paramSpace.zeroVector());
minBound[0] = -10.0;
QUESO::GslVector maxBound(paramSpace.zeroVector());
maxBound[0] = 10.0;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> domain("", paramSpace,
minBound, maxBound);
QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> prior("", domain);
Likelihood<QUESO::GslVector, QUESO::GslMatrix> likelihood("", domain);
QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix> posterior("",
domain);
QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix> ip("",
NULL, prior, likelihood, posterior);
QUESO::GslVector initialValues(paramSpace.zeroVector());
initialValues[0] = 9.0;
QUESO::GslMatrix proposalCovarianceMatrix(paramSpace.zeroVector());
proposalCovarianceMatrix(0, 0) = 1.0;
ip.seedWithMAPEstimator();
ip.solveWithBayesMetropolisHastings(NULL, initialValues,
&proposalCovarianceMatrix);
// The first sample should be the seed
QUESO::GslVector first_sample(paramSpace.zeroVector());
posterior.realizer().realization(first_sample);
// Looser tolerance for the derivative calculated by using a finite
// difference
if (std::abs(first_sample[0]) > 1e-5) {
std::cerr << "seedWithMAPEstimator failed. Seed was: " << first_sample[0]
<< std::endl;
std::cerr << "Actual seed should be 0.0" << std::endl;
queso_error();
}
return 0;
}
void VideoContent::setup ( string _path , ofRectangle _bounds )
{
path = ofToDataPath( _path ) ;
scale = 1.0f ;
initialValues() ;
maxScale = 1.0f ;
updateFrameOnce = false ;
bUseFboTexture = false ;
}
void VideoContent::transitionIn ( float time , float delay )
{
initialValues() ;
video.loadMovie( path ) ;
updateFrameOnce = true ;
video.play() ;
videoFbo.allocate( video.getWidth() , video.getHeight() ) ;
videoFbo.begin() ;
ofClear( 0 , 0 , 0, 1 ) ;
drawIntoTexture() ;
videoFbo.end() ;
Tweenzor::add( &alpha , 0.0f , 1.0f , delay , time , EASE_OUT_QUAD ) ;
Tweenzor::addCompleteListener( Tweenzor::getTween( &alpha ) , this , &VideoContent::transitionInComplete ) ;
}
void BanditSingleStumpLearner::load(nor_utils::StreamTokenizer& st)
{
//recalculate the initial values
//these values can be stored also avoiding the recalculation of this values (maybe this would be better solution)
if ( ! this->_banditAlgo->isInitialized() ) {
const int numColumns = _pTrainingData->getNumAttributes();
const int armNumber = _banditAlgo->getArmNumber();
if ( numColumns < armNumber )
{
cerr << "The number of colums smaller than the number of the arms!!!!!!" << endl;
exit( -1 );
}
_banditAlgo->setArmNumber( numColumns );
vector<AlphaReal> initialValues(0);
_banditAlgo->initialize( initialValues );
}
// Calling the super-class method
FeaturewiseLearner::load(st);
_threshold = UnSerialization::seekAndParseEnclosedValue<float>(st, "threshold");
stringstream thresholdString;
thresholdString << _threshold;
_id = _id + thresholdString.str();
//restore the rewards
UnSerialization::seekAndParseVectorTag( st, "rewards", "arm", _armsForPulling, _rewards );
_reward = -numeric_limits<float>::infinity();
for( int i=0; i<(int)_rewards.size(); i++ )
{
_banditAlgo->receiveReward( _armsForPulling[i], _rewards[i] );
if ( _reward < _rewards[i] ) _reward = (float)_rewards[i];
}
}
void solveSip(const uqFullEnvironmentClass& env)
{
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Entering solveSip()..."
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 1 of 5: Instantiate the parameter space
////////////////////////////////////////////////////////
unsigned int p = 2;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL);
uqGslVectorClass aVec(paramSpace.zeroVector());
aVec[0] = 2.;
aVec[1] = 5.;
uqGslVectorClass xGiven(paramSpace.zeroVector());
xGiven[0] = -1.;
xGiven[1] = 7.;
////////////////////////////////////////////////////////
// Step 2 of 5: Instantiate the parameter domain
////////////////////////////////////////////////////////
//uqGslVectorClass paramMins (paramSpace.zeroVector());
//uqGslVectorClass paramMaxs (paramSpace.zeroVector());
//paramMins [0] = -1.e+16;
//paramMaxs [0] = 1.e+16;
//paramMins [1] = -1.e+16;
//paramMaxs [1] = 1.e+16;
//uqBoxSubsetClass<uqGslVectorClass,uqGslMatrixClass> paramDomain("param_",paramSpace,paramMins,paramMaxs);
uqVectorSetClass<uqGslVectorClass,uqGslMatrixClass>* paramDomain = ¶mSpace;
////////////////////////////////////////////////////////
// Step 3 of 5: Instantiate the likelihood function object
////////////////////////////////////////////////////////
unsigned int n = 5;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", n, NULL);
uqGslVectorClass yMeanVec(dataSpace.zeroVector());
double tmp = scalarProduct(aVec,xGiven);
for (unsigned int i = 0; i < n; ++i) {
yMeanVec[i] = tmp;
}
double sigmaEps = 2.1;
uqGslMatrixClass yCovMat(dataSpace.zeroVector());
tmp = sigmaEps*sigmaEps;
for (unsigned int i = 0; i < n; ++i) {
yCovMat(i,i) = tmp;
}
uqGslVectorClass ySamples(dataSpace.zeroVector());
uqGaussianVectorRVClass<uqGslVectorClass,uqGslMatrixClass> yRv("y_", dataSpace, yMeanVec, yCovMat);
yRv.realizer().realization(ySamples);
double ySampleMean = 0.;
for (unsigned int i = 0; i < n; ++i) {
ySampleMean += ySamples[i];
}
ySampleMean /= ((double) n);
struct likelihoodDataStruct likelihoodData;
likelihoodData.aVec = &aVec;
likelihoodData.sigmaEps = sigmaEps;
likelihoodData.ySamples = &ySamples;
uqGenericScalarFunctionClass<uqGslVectorClass,uqGslMatrixClass>
likelihoodFunctionObj("like_",
*paramDomain,
likelihoodRoutine,
(void *) &likelihoodData,
true); // routine computes [ln(function)]
////////////////////////////////////////////////////////
// Step 4 of 5: Instantiate the inverse problem
////////////////////////////////////////////////////////
uqGslVectorClass xPriorMeanVec(paramSpace.zeroVector());
xPriorMeanVec[0] = 0.;
xPriorMeanVec[1] = 0.;
uqGslMatrixClass sigma0Mat(paramSpace.zeroVector());
sigma0Mat(0,0) = 1.e-3;
sigma0Mat(0,1) = 0.;
sigma0Mat(1,0) = 0.;
sigma0Mat(1,1) = 1.e-3;
uqGslMatrixClass sigma0MatInverse(paramSpace.zeroVector());
sigma0MatInverse = sigma0Mat.inverse();
uqGaussianVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain, xPriorMeanVec, sigma0MatInverse);
uqGenericVectorRVClass <uqGslVectorClass,uqGslMatrixClass> postRv ("post_", paramSpace);
uqStatisticalInverseProblemClass<uqGslVectorClass,uqGslMatrixClass> sip("sip_", NULL, priorRv, likelihoodFunctionObj, postRv);
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "In solveSip():"
<< "\n p = " << p
<< "\n xGiven = " << xGiven
<< "\n sigma0Mat = " << sigma0Mat
<< "\n sigma0MatInverse = " << sigma0MatInverse
<< "\n aVec = " << aVec
<< "\n n = " << n
<< "\n sigmaEps = " << sigmaEps
<< "\n yMeanVec = " << yMeanVec
<< "\n yCovMat = " << yCovMat
<< "\n ySamples = " << ySamples
<< "\n ySampleMean = " << ySampleMean
<< std::endl;
}
uqGslMatrixClass sigmaMatInverse(paramSpace.zeroVector());
sigmaMatInverse = matrixProduct(aVec,aVec);
sigmaMatInverse *= (((double) n)/sigmaEps/sigmaEps);
sigmaMatInverse += sigma0Mat;
uqGslMatrixClass sigmaMat(paramSpace.zeroVector());
sigmaMat = sigmaMatInverse.inverse();
uqGslVectorClass muVec(paramSpace.zeroVector());
muVec = sigmaMat * aVec;
muVec *= (((double) n) * ySampleMean)/sigmaEps/sigmaEps;
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "In solveSip():"
<< "\n muVec = " << muVec
<< "\n sigmaMat = " << sigmaMat
<< "\n sigmaMatInverse = " << sigmaMatInverse
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 5 of 5: Solve the inverse problem
////////////////////////////////////////////////////////
uqGslVectorClass initialValues(paramSpace.zeroVector());
initialValues[0] = 25.;
initialValues[1] = 25.;
uqGslMatrixClass proposalCovMat(paramSpace.zeroVector());
proposalCovMat(0,0) = 10.;
proposalCovMat(0,1) = 0.;
proposalCovMat(1,0) = 0.;
proposalCovMat(1,1) = 10.;
sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat);
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Leaving solveSip()"
<< std::endl;
}
return;
}
void solveSip(const uqFullEnvironmentClass& env, bool useML)
{
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Entering solveSip()..."
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 1 of 5: Instantiate the parameter space
////////////////////////////////////////////////////////
unsigned int p = 1;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL);
uqGslVectorClass bVec(paramSpace.zeroVector());
bVec[0] = 0.045213;
////////////////////////////////////////////////////////
// Step 2 of 5: Instantiate the parameter domain
////////////////////////////////////////////////////////
//uqGslVectorClass paramMins (paramSpace.zeroVector());
//uqGslVectorClass paramMaxs (paramSpace.zeroVector());
//paramMins [0] = -1.e+16;
//paramMaxs [0] = 1.e+16;
//paramMins [1] = -1.e+16;
//paramMaxs [1] = 1.e+16;
//uqBoxSubsetClass<uqGslVectorClass,uqGslMatrixClass> paramDomain("param_",paramSpace,paramMins,paramMaxs);
uqVectorSetClass<uqGslVectorClass,uqGslMatrixClass>* paramDomain = ¶mSpace;
////////////////////////////////////////////////////////
// Step 3 of 5: Instantiate the likelihood function object
////////////////////////////////////////////////////////
unsigned int nAll = 100000;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpaceAll(env, "data_", nAll, NULL);
double sigmaTotal = bVec[0]/2.;
std::set<unsigned int> tmpSet;
tmpSet.insert(env.subId());
uqGslVectorClass ySamplesAll(dataSpaceAll.zeroVector());
ySamplesAll.subReadContents("input/dataPoints",
"m",
tmpSet);
unsigned int numCases = 5;
std::vector<unsigned int> ns(numCases,0);
ns[0] = 1;
ns[1] = 10;
ns[2] = 100;
ns[3] = 500;
ns[4] = 1000;
for (unsigned int caseId = 0; caseId < numCases; ++caseId) {
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", ns[caseId], NULL);
uqGslVectorClass ySamples(dataSpace.zeroVector());
for (unsigned int i = 0; i < ns[caseId]; ++i) {
ySamples[i] = ySamplesAll[i];
}
struct likelihoodDataStruct likelihoodData;
likelihoodData.bVec = &bVec;
likelihoodData.sigmaTotal = sigmaTotal;
likelihoodData.ySamples = &ySamples;
uqGenericScalarFunctionClass<uqGslVectorClass,uqGslMatrixClass>
likelihoodFunctionObj("like_",
*paramDomain,
likelihoodRoutine,
(void *) &likelihoodData,
true); // routine computes [ln(function)]
////////////////////////////////////////////////////////
// Step 4 of 5: Instantiate the inverse problem
////////////////////////////////////////////////////////
uqUniformVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain);
uqGenericVectorRVClass<uqGslVectorClass,uqGslMatrixClass> postRv ("post_", paramSpace);
char prefixStr[16+1];
sprintf(prefixStr,"sip%d_",caseId+1);
uqStatisticalInverseProblemClass<uqGslVectorClass,uqGslMatrixClass> sip(prefixStr, NULL, priorRv, likelihoodFunctionObj, postRv);
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "In solveSip():"
<< "\n caseId = " << caseId
<< "\n prefixStr = " << prefixStr
<< "\n p = " << p
<< "\n bVec = " << bVec
<< "\n ns[caseId] = " << ns[caseId]
<< "\n sigmaTotal = " << sigmaTotal
<< "\n ySamples = " << ySamples
<< "\n useML = " << useML
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 5 of 5: Solve the inverse problem
////////////////////////////////////////////////////////
uqGslVectorClass initialValues(paramSpace.zeroVector());
initialValues[0] = 0.;
uqGslMatrixClass proposalCovMat(paramSpace.zeroVector());
proposalCovMat(0,0) = 1.;
if (useML) {
sip.solveWithBayesMLSampling();
}
else {
sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat);
}
} // for caseId
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Leaving solveSip()"
<< std::endl;
}
return;
}
void solveSip(const uqFullEnvironmentClass& env, bool useML)
{
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Entering solveSip()..."
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 1 of 5: Instantiate the parameter space
////////////////////////////////////////////////////////
unsigned int p = 1;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> paramSpace(env, "param_", p, NULL);
uqGslVectorClass aVec(paramSpace.zeroVector());
aVec[0] = 126831.7;
uqGslVectorClass bVec(paramSpace.zeroVector());
bVec[0] = 112136.1;
////////////////////////////////////////////////////////
// Step 2 of 5: Instantiate the parameter domain
////////////////////////////////////////////////////////
//uqGslVectorClass paramMins (paramSpace.zeroVector());
//uqGslVectorClass paramMaxs (paramSpace.zeroVector());
//paramMins [0] = -1.e+16;
//paramMaxs [0] = 1.e+16;
//paramMins [1] = -1.e+16;
//paramMaxs [1] = 1.e+16;
//uqBoxSubsetClass<uqGslVectorClass,uqGslMatrixClass> paramDomain("param_",paramSpace,paramMins,paramMaxs);
uqVectorSetClass<uqGslVectorClass,uqGslMatrixClass>* paramDomain = ¶mSpace;
////////////////////////////////////////////////////////
// Step 3 of 5: Instantiate the likelihood function object
////////////////////////////////////////////////////////
unsigned int n = 400;
uqVectorSpaceClass<uqGslVectorClass,uqGslMatrixClass> dataSpace(env, "data_", n, NULL);
double sigmaTotal = 4229.55;
std::set<unsigned int> tmpSet;
tmpSet.insert(env.subId());
uqGslVectorClass ySamples(dataSpace.zeroVector());
ySamples.subReadContents("input/dataPoints",
"m",
tmpSet);
struct likelihoodDataStruct likelihoodData;
likelihoodData.aVec = &aVec;
likelihoodData.bVec = &bVec;
likelihoodData.sigmaTotal = sigmaTotal;
likelihoodData.ySamples = &ySamples;
uqGenericScalarFunctionClass<uqGslVectorClass,uqGslMatrixClass>
likelihoodFunctionObj("like_",
*paramDomain,
likelihoodRoutine,
(void *) &likelihoodData,
true); // routine computes [ln(function)]
////////////////////////////////////////////////////////
// Step 4 of 5: Instantiate the inverse problem
////////////////////////////////////////////////////////
uqUniformVectorRVClass<uqGslVectorClass,uqGslMatrixClass> priorRv("prior_", *paramDomain);
uqGenericVectorRVClass<uqGslVectorClass,uqGslMatrixClass> postRv ("post_", paramSpace);
uqStatisticalInverseProblemClass<uqGslVectorClass,uqGslMatrixClass> sip("sip_", NULL, priorRv, likelihoodFunctionObj, postRv);
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "In solveSip():"
<< "\n p = " << p
<< "\n aVec = " << aVec
<< "\n bVec = " << bVec
<< "\n n = " << n
<< "\n sigmaTotal = " << sigmaTotal
<< "\n ySamples = " << ySamples
<< "\n useML = " << useML
<< std::endl;
}
////////////////////////////////////////////////////////
// Step 5 of 5: Solve the inverse problem
////////////////////////////////////////////////////////
uqGslVectorClass initialValues(paramSpace.zeroVector());
initialValues[0] = 0.;
uqGslMatrixClass proposalCovMat(paramSpace.zeroVector());
proposalCovMat(0,0) = 1.;
if (useML) {
sip.solveWithBayesMLSampling();
}
else {
sip.solveWithBayesMetropolisHastings(NULL,initialValues,&proposalCovMat);
}
if ((env.subDisplayFile()) && (env.displayVerbosity() >= 2)) {
*env.subDisplayFile() << "Leaving solveSip()"
<< std::endl;
}
return;
}
