Пример #1
0
void			_LikelihoodFunction::ComputeSiteLikelihoodsForABlock	(long index, _Parameter* results, _SimpleList& scalers, long branchIndex, _SimpleList* branchValues, char mpiRunMode)
// assumes that results is at least blockLength slots long
{
	if (blockDependancies.lData[index])
		PopulateConditionalProbabilities(index, mpiRunMode == _hyphyLFMPIModeREL ?_hyphyLFConditionMPIIterate:_hyphyLFConditionProbsWeightedSum, results, scalers, branchIndex, branchValues);	
	else
	{
		ComputeBlock		(index, results, -1, branchIndex, branchValues);
		scalers.Clear		();
		scalers.Duplicate   (siteCorrections(index));
	}
}
Пример #2
0
Observations
MultivariateModel
::SimulateData(io::DataSettings &DS) 
{
  /// This function simulates observations (Patients and their measurements y_ij at different time points t_ij) 
  /// according to the model, with a given noise level e_ij, such that y_ij = f(t_ij) + e_ij
  /// Their is two option: 
  /// 1) The model is not initialized (neither random variables of number of realizations) and it has to be
  /// This case corresponds to simulated data used to test the model, meaning if it can recover the random variables
  /// used to simulate the data
  /// 2) The model is already initialized, thus it should rely on its current state (random variables, realizations, ...)
  /// This case corresponds to new data, for a dataset augmentation for instance
  
  // TODO :
  /// PITFALL  : As for now, only the first option is implemented
  /// PITFALL2 : Take a closer look at / merge with InitializeFakeRandomVariables 
  
  
  /// Initialize the model
  m_ManifoldDimension = DS.GetCognitiveScoresDimension();
  m_NumberOfSubjects  = DS.GetNumberOfSimulatedSubjects();
  
  m_RealizationsPerRandomVariable["G"] = 1;
  
  for(size_t i = 1; i < m_ManifoldDimension; ++i)
    m_RealizationsPerRandomVariable["Delta#" + std::to_string(i)] = 1;

  for(size_t i = 0; i <  m_NbIndependentSources*(m_ManifoldDimension - 1); ++i)
    m_RealizationsPerRandomVariable["Beta#" + std::to_string(i)] = 1;

  m_RealizationsPerRandomVariable["Ksi"] = m_NumberOfSubjects;
  m_RealizationsPerRandomVariable["Tau"] = m_NumberOfSubjects;

  for(int i = 0; i < m_NbIndependentSources; ++i)
    m_RealizationsPerRandomVariable["S#" + std::to_string(i)] = m_NumberOfSubjects;

  auto R = SimulateRealizations();
  
  /// Update the model
  m_G = exp(R.at("G", 0));
  ComputeDeltas(R);
  ComputeOrthonormalBasis();
  ComputeAMatrix(R);
  ComputeSpaceShifts(R);
  ComputeBlock(R);
  
  /// Simulate the data
  std::random_device RD;
  std::mt19937 RNG(RD());
  std::uniform_int_distribution<int> Uni(DS.GetMinimumNumberOfObservations(), DS.GetMaximumNumberOfObservations());
  UniformRandomVariable NumberOfTimePoints(60, 95);
  GaussianRandomVariable Noise(0, m_Noise->GetVariance());
  
  /// Simulate the data
  Observations Obs;
  for(int i = 0; i < m_NumberOfSubjects; ++i)
  { 
    /// Get a random number of timepoints and sort them
    VectorType T = NumberOfTimePoints.Samples(Uni(RNG));
    T.sort();
    m_SubjectTimePoints.push_back(T);
    
    /// Simulate the data base on the time-points
    IndividualObservations IO(T);   
    std::vector<VectorType> Landmarks;
    for(size_t j = 0; j < T.size(); ++j)
    {
      Landmarks.push_back(ComputeParallelCurve(i, j) + Noise.Samples(m_ManifoldDimension));
    }
    
    IO.AddLandmarks(Landmarks);
    Obs.AddIndividualData(IO);
  }
  
  /// Initialize the observation and model attributes
  Obs.InitializeGlobalAttributes();
  m_IndividualObservationDate = Obs.GetObservations();
  m_SumObservations           = Obs.GetTotalSumOfLandmarks();
  m_NbTotalOfObservations     = Obs.GetTotalNumberOfObservations();
  
  return Obs;
  
}
Пример #3
0
void
MultivariateModel
::UpdateModel(const Realizations &R, int Type,
            const std::vector<std::string, std::allocator<std::string>> Names)
{
  /// Given a list of names (which in fact corresponds to the variables that have potentially changed),
  /// the function updates the parameters associated to these names
  
  
  /// Possible parameters to update, depending on the name being in "vect<> Names"
  bool ComputeG = false;
  bool ComputeDelta = false;
  bool ComputeBasis = false;
  bool ComputeA = false;
  bool ComputeSpaceShift = false;
  bool ComputeBlock_ = false;
  bool IndividualOnly = (Type > -1);
  
  /// Parameters to update, depending on the names called
  for(auto it = Names.begin(); it != Names.end(); ++it)
  {
    std::string Name = it->substr(0, it->find_first_of("#"));
    if(Name == "None")
    {
      continue;
    }
    else if(Name == "Ksi" or Name == "Tau") 
    {
      continue;
    }
    else if("G" == Name)
    {
      IndividualOnly = false;
      ComputeBasis = true;
      ComputeA = true;
      ComputeSpaceShift = true;
      ComputeBlock_ = true;
    }
    else if("Delta" == Name)
    {
      IndividualOnly = false;
      ComputeBasis = true;
      ComputeA = true;
      ComputeSpaceShift = true;
      ComputeBlock_ = true;
    }
    else if("Beta" == Name) 
    {
      IndividualOnly = false;
      ComputeA = true;
      ComputeSpaceShift = true;
    }
    else if("S" == Name)
    {
      ComputeSpaceShift = true;
    }
    else if("All" == Name)
    {
      ComputeSubjectTimePoint(R, -1);
      IndividualOnly = false;
      ComputeG = true;
      ComputeDelta = true;
      ComputeBasis = true;
      ComputeA = true;
      ComputeSpaceShift = true;
      ComputeBlock_ = true;
    } 
    else
    {
      std::cerr << "The realization does not exist in the multivariate model > update model" << std::endl;
    }
  }
  
  
  // TODO : To parse it even faster, update just the coordinates within the names
  if(IndividualOnly) ComputeSubjectTimePoint(R, Type);
  
  if(ComputeG)          m_G = exp(R.at("G", 0));
  if(ComputeDelta)      ComputeDeltas(R);
  if(ComputeBasis)      ComputeOrthonormalBasis();
  if(ComputeA)          ComputeAMatrix(R);
  if(ComputeSpaceShift) ComputeSpaceShifts(R);
  if(ComputeBlock_)     ComputeBlock(R);
}
Пример #4
0
void			_LikelihoodFunction::PopulateConditionalProbabilities	(long index, char runMode, _Parameter* buffer, _SimpleList& scalers, long branchIndex, _SimpleList* branchValues)
// this function computes site probabilties for each rate class (or something else that involves iterating over rate classes)
// see run options below

// run mode can be one of the following

// _hyphyLFConditionProbsRawMatrixMode : simply   populate an M (number of rate classes) x S (number of site patterns) matrix of conditional likelihoods
//   : expected minimum dimension of buffer is M*S
//	 : scalers will have M*S entries laid out as S for rate class 0, S for rate class 1, .... S for rate class M-1

// _hyphyLFConditionProbsScaledMatrixMode : simply   populate an M (number of rate classes) x S (number of site patterns) and scale to the lowest multiplier
//   : expected minimum dimension of buffer is M*S
//	 : scalers will have S entries

// _hyphyLFConditionProbsWeightedSum : compute  a sum for each site using weighted by the probability of a given category
//   : expected minimum dimension of buffer is 2*S
//	 : scalers will have S entries
//   : **note that the behavior is different if there are HMM (or constant on partition) variables 
//	 : the size of the buffer is S*(N+1), where N is the cumulative number of categories in such variables for this partition
//   : the size of the scaler is also S*N
//	 : the code will behave as _hyphyLFConditionProbsScaledMatrixMode with all other category variables 
//   : summed CONDITIONED on the values of HMM/Constant on partition 

// _hyphyLFConditionProbsMaxProbClass : compute the category index of maximum probability  
//   : expected minimum dimension of buffer is 3*S -- the result goes into offset 0
//	 : scalers will have S entries 

// _hyphyLFConditionProbsClassWeights : compute the weight of each rate class index 
//   : expected minimum dimension of buffer is M
//	 : scalers will have no entries

// _hyphyLFConditionMPIIterate : compute conditional likelihoods of the partition using MPI
//	 : run mode effectively the same as _hyphyLFConditionProbsWeightedSum
{
	_List				*traversalPattern		= (_List*)categoryTraversalTemplate(index),
						*variables			    = (_List*)((*traversalPattern)(0)),
						*catWeigths				= nil;

	_SimpleList			*categoryCounts			= (_SimpleList*)((*traversalPattern)(1)),
						*categoryOffsets		= (_SimpleList*)((*traversalPattern)(2)),
						*hmmAndCOP				= (_SimpleList*)((*traversalPattern)(3)),
						categoryValues			(categoryCounts->lLength,0,0);
	
	long				totalSteps				= categoryOffsets->lData[0] * categoryCounts->lData[0],
						catCount				= variables->lLength-1,
						blockLength				= BlockLength(index),
						hmmCatSize				= hmmAndCOP->Element(-1),
						hmmCatCount				= hmmAndCOP->lLength?(totalSteps/hmmCatSize):0,
						currentHMMCat			= 1,
						arrayDim				;
	
	bool				isTrivial				= variables->lLength == 0,
						switchingHMM			= false;
	
	_CategoryVariable   *catVariable;
	
	
	switch (runMode)
	{
		case _hyphyLFConditionProbsRawMatrixMode:
			arrayDim = catCount*blockLength;
			break;
		case _hyphyLFConditionProbsClassWeights:
			arrayDim = 0;
			break;
		default:
			arrayDim = hmmCatCount?blockLength*hmmCatSize:blockLength;
	}
	
	if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionMPIIterate || runMode == _hyphyLFConditionProbsClassWeights)
	{
		if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionMPIIterate)
		{
			long upperBound = hmmCatCount?hmmAndCOP->Element(-1)*blockLength:blockLength;
			for (long r = 0; r < upperBound; r++)
				buffer[r] = 0.;
		}
		catWeigths = new _List;
	}
	else
		if (runMode == _hyphyLFConditionProbsMaxProbClass)
			for (long r = 0, r2 = 2*blockLength; r < blockLength; r++, r2++)
			{
				buffer[r] = 0.0; buffer[r2] = 0.0;
			}
	
	for					(long currentCat		= 0; currentCat <= catCount; currentCat++)
	{
		(catVariable = ((_CategoryVariable**)(variables->lData))[currentCat])->Refresh();
		catVariable->SetIntervalValue(0,true);
		if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionMPIIterate || runMode == _hyphyLFConditionProbsClassWeights)
			(*catWeigths) << catVariable->GetWeights();
	}
	
		
	scalers.Populate	(arrayDim,0,0);
	
#ifdef __HYPHYMPI__
	_GrowingVector * computedWeights = nil;
	if (runMode == _hyphyLFConditionMPIIterate)
	{
		computedWeights = new _GrowingVector;
	}
	long				mpiTasksSent = 0;
#endif	
	
	for					(long pass = 0; pass < 1+(runMode == _hyphyLFConditionMPIIterate); pass++)
	{
		for					(long currentRateCombo  = 0; currentRateCombo < totalSteps; currentRateCombo++)
		{

			// setting each category variable to its appropriate value 
			
			_Parameter		 currentRateWeight = 1.;
			if (pass == 0)
			{
				if (!isTrivial)
				{
					long remainder = currentRateCombo % categoryCounts->lData[catCount];
					
					if (hmmCatCount)
					{
						currentHMMCat = currentRateCombo / hmmCatCount;
						switchingHMM = (currentRateCombo % hmmCatCount) == 0;
					}
					
					if (currentRateCombo && remainder  == 0)
					{
						categoryValues.lData[catCount] = 0;
						(((_CategoryVariable**)(variables->lData))[catCount])->SetIntervalValue(0);
						for (long uptick = catCount-1; uptick >= 0; uptick --)
						{
							categoryValues.lData[uptick]++;
							if (categoryValues.lData[uptick] == categoryCounts->lData[uptick])
							{
								categoryValues.lData[uptick] = 0;
								(((_CategoryVariable**)(variables->lData))[uptick])->SetIntervalValue(0);
							}
							else
							{
								(((_CategoryVariable**)(variables->lData))[uptick])->SetIntervalValue(categoryValues.lData[uptick]);
								break;
							}
						}
					}
					else
					{
						if (currentRateCombo)
						{
							categoryValues.lData[catCount]++;
							(((_CategoryVariable**)(variables->lData))[catCount])->SetIntervalValue(remainder);
						}
					}
				}
			
				if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionProbsClassWeights || runMode == _hyphyLFConditionMPIIterate)
				{
					for					(long currentCat		= hmmCatCount; currentCat <= catCount; currentCat++)
						currentRateWeight *= ((_Matrix**)catWeigths->lData)[currentCat]->theData[categoryValues.lData[currentCat]];
					
	#ifdef __HYPHYMPI__
					if (runMode == _hyphyLFConditionMPIIterate && pass == 0)
						computedWeights->Store(currentRateWeight);
	#endif				
					if (runMode == _hyphyLFConditionProbsClassWeights)
					{
						buffer [currentRateCombo] = currentRateWeight;
						continue;
					}
					else
						if (currentRateWeight == 0.0) // nothing to do, eh?
							continue;
	#ifdef __HYPHYMPI__
						else
						{
							if (runMode == _hyphyLFConditionMPIIterate)
							{
								SendOffToMPI (currentRateCombo);
								mpiTasksSent ++;
								continue;
							}
						}
	#endif						
				}
			}
			
			long useThisPartitonIndex = currentRateCombo;
			
#ifdef __HYPHYMPI__
			if (runMode == _hyphyLFConditionMPIIterate)
			{
				MPI_Status	   status;
				ReportMPIError(MPI_Recv (resTransferMatrix.theData, resTransferMatrix.GetSize(), MPI_DOUBLE, MPI_ANY_SOURCE , HYPHY_MPI_DATA_TAG, MPI_COMM_WORLD,&status),true);				
				useThisPartitonIndex = status.MPI_SOURCE-1;
				currentRateWeight    = computedWeights->theData[useThisPartitonIndex];
			}
#endif						
			
			// now that the categories are set we can proceed with the computing step
			long			 indexShifter					= blockLength * useThisPartitonIndex;
			long			 *siteCorrectors				= ((_SimpleList**)siteCorrections.lData)[index]->lLength?
															 (((_SimpleList**)siteCorrections.lData)[index]->lData) + indexShifter
															 :nil;
			

			if (runMode == _hyphyLFConditionProbsRawMatrixMode || runMode == _hyphyLFConditionProbsScaledMatrixMode) 
				// populate the matrix of conditionals and scaling factors
			{
				_Parameter	_hprestrict_ *bufferForThisCategory = buffer + indexShifter;

				ComputeBlock	(index, bufferForThisCategory, useThisPartitonIndex, branchIndex, branchValues);
				if (usedCachedResults)
				{
					bool saveFR = forceRecomputation;
					forceRecomputation = true;
					ComputeBlock	(index, bufferForThisCategory, useThisPartitonIndex, branchIndex, branchValues);
					forceRecomputation = saveFR;
				}
				
				if (runMode == _hyphyLFConditionProbsRawMatrixMode)
					for (long p = 0; p < blockLength; p++)
						scalers.lData[p+indexShifter] = siteCorrectors[p];
				else
				{
					if (siteCorrectors)
					{
						for (long r1 = 0; r1 < blockLength; r1++)
						{
							long scv			  = *siteCorrectors,
								 scalerDifference = scv-scalers.lData[r1];
							
							if (scalerDifference > 0) 
							// this class has a _bigger_ scaling factor than at least one other class
							// hence it needs to be scaled down (unless it's the first class)
							{
								if (useThisPartitonIndex==0) //(scalers.lData[r1] == -1)
									scalers.lData[r1] = scv;
								else
									bufferForThisCategory[r1] *= acquireScalerMultiplier (scalerDifference);
							}
							else
							{
								if (scalerDifference < 0) 
								// this class is a smaller scaling factor, i.e. its the biggest among all those
								// considered so far; all other classes need to be scaled down
								{							
									_Parameter scaled = acquireScalerMultiplier (-scalerDifference);
									for (long z = indexShifter+r1-blockLength; z >= 0; z-=blockLength)
										buffer[z] *= scaled;
									
									scalers.lData[r1] = scv;
								}
							}
							siteCorrectors++;
						}
					}
				}
			} 
			else
			{
				if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionProbsMaxProbClass || runMode == _hyphyLFConditionMPIIterate) 
				{
					//if (branchIndex>=0)
					//	((_TheTree*)LocateVar(theTrees.lData[index]))->AddBranchToForcedRecomputeList (branchIndex+((_TheTree*)LocateVar(theTrees.lData[index]))->GetLeafCount());
					
	#ifdef			__HYPHYMPI__
					if (runMode == _hyphyLFConditionMPIIterate)
					{
						long offset = resTransferMatrix.GetVDim();

						for (long k = 0; k < blockLength; k++)
						{
							buffer[blockLength+k] = resTransferMatrix.theData[k];
							siteCorrectors[k]     = resTransferMatrix.theData[k+offset];
						}
					}
					else
						
#endif
					
					ComputeBlock	(index, buffer + (hmmCatCount?hmmCatSize:1)*blockLength, useThisPartitonIndex, branchIndex, branchValues);
					
					if (runMode != _hyphyLFConditionMPIIterate && usedCachedResults)
					{
						bool saveFR = forceRecomputation;
						forceRecomputation = true;
						ComputeBlock	(index, buffer + (hmmCatCount?hmmCatSize:1)*blockLength, useThisPartitonIndex, branchIndex, branchValues);
						forceRecomputation = saveFR;
					}

					
					if (runMode == _hyphyLFConditionProbsWeightedSum || runMode == _hyphyLFConditionMPIIterate)
					{
						long lowerBound  = hmmCatCount?blockLength*currentHMMCat:0,
							 upperBound  = hmmCatCount?blockLength*(1+currentHMMCat):blockLength,
							 lowerBound2 = hmmCatCount?(hmmCatSize*blockLength):blockLength;
									
						
						for (long r1 = lowerBound, r2 = lowerBound2; r1 < upperBound; r1++,r2++)
						{
							if (siteCorrectors)
							{
								long scv = *siteCorrectors;
								
								if (scv < scalers.lData[r1]) // this class has a _smaller_ scaling factor
								{
									buffer[r1] = currentRateWeight * buffer[r2] + buffer[r1] * acquireScalerMultiplier (scalers.lData[r1] - scv);
									scalers.lData[r1] = scv;
								}
								else
								{
									if (scv > scalers.lData[r1]) // this is a _larger_ scaling factor
										buffer[r1] += currentRateWeight * buffer[r2] * acquireScalerMultiplier (scv - scalers.lData[r1]);							
									else // same scaling factors
										buffer[r1] += currentRateWeight * buffer[r2];
								}
								
								siteCorrectors++;
							}
							else
								buffer[r1] += currentRateWeight * buffer[r2];
							
						}		
					}
					else // runMode = _hyphyLFConditionProbsMaxProbClass
					{
						for (long r1 = blockLength*2, r2 = blockLength, r3 = 0; r3 < blockLength; r1++,r2++,r3++)
						{
							bool doChange = false;
							if (siteCorrectors)
							{
								long scv  = *siteCorrectors,
									 diff = scv - scalers.lData[r3];
								
								if (diff<0) // this has a _smaller_ scaling factor
								{
									_Parameter scaled = buffer[r1]*acquireScalerMultiplier (diff);
									if (buffer[r2] > scaled)
										doChange = true;
									else
										buffer[r1] = scaled;
									scalers.lData[r3] = scv;
								}
								else
								{
									if (diff>0) // this is a _larger_ scaling factor
										buffer[r2] *= acquireScalerMultiplier (-diff);		
									doChange = buffer[r2] > buffer[r1] && ! CheckEqual (buffer[r2],buffer[r1]);
								}
								
								siteCorrectors++;
							}
							else
								doChange = buffer[r2] > buffer[r1] && ! CheckEqual (buffer[r2],buffer[r1]);
							
							if (doChange)
							{
								buffer[r1]		   = buffer[r2];
								buffer[r3]         = useThisPartitonIndex;
							}
						}						
					}
				}
			}
#ifdef __HYPHYMPI__
			if (--mpiTasksSent == 0)
				break;
#endif	
		}
	}
#ifdef __HYPHYMPI__
	DeleteObject (computedWeights);
#endif	
	DeleteObject (catWeigths);
}