newstates = zeros_like(states)
# --------------
poissonparameters = parameters[2, :] * (parameters[0, :]**2) / parameters[1, :]
poissonparameters = repeat(poissonparameters[:,newaxis], Nx, axis = 1)
for indextheta in range(Ntheta):
allK = random.poisson(lam = poissonparameters[indextheta,:])
allK = array(allK).reshape(Nx)
sumK = sum(allK)
alluniforms = random.uniform(size = 2 * sumK)
subresults = subtransitionAndWeight(states[..., indextheta], y, parameters[:, indextheta], \
alluniforms, allK)
newstates[..., indextheta] = subresults["states"]
weights[..., indextheta] = subresults["weights"]
# --------------
return {"states": newstates , "weights": weights}
modelx = SSM("SV one-factor", xdimension = 2, ydimension = 1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionAndWeight)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([0.5, 0.0625, 0.01])
THREADS_PER_BLOCK_Y = 16
y = array(y, dtype = float32)
states = states.astype(float32)
parameters = parameters.astype(float32)
Nx, statedim, Ntheta = states.shape
noise = random.normal(size = (Nx, Ntheta), loc = 0, scale = 1).astype(float32)
num_blocks_x = int(math.ceil(Nx / THREADS_PER_BLOCK_X))
num_blocks_y = int(math.ceil(Ntheta / THREADS_PER_BLOCK_Y))
transitionGF(drv.In(y), drv.InOut(states), \
drv.In(parameters), \
drv.InOut(noise), \
drv.In(array(t, dtype = float32)), \
drv.In(array(Nx, dtype = int32)), \
drv.In(array(Ntheta, dtype = int32)), \
drv.In(array(statedim, dtype = int32)), \
block = (THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y, 1), grid = (num_blocks_x, num_blocks_y))
return {"states": states, "weights": noise}
modelx = SSM(name = "Periodic Gaussian model x (using CUDA)", xdimension = 1, ydimension = 1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionCUDA)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([10, 1])
return {"states": states, "weights": weights}
def transitionAndWeight(states, y, parameters, t):
Nx = states.shape[0]
Ntheta = states.shape[2]
weights = zeros((Nx, Ntheta))
newstates = zeros_like(states)
# --------------
poissonparameters = parameters[2, :] * (parameters[0, :] ** 2) / parameters[1, :]
poissonparameters = repeat(poissonparameters[:, newaxis], Nx, axis=1)
for indextheta in range(Ntheta):
allK = random.poisson(lam=poissonparameters[indextheta, :])
allK = array(allK).reshape(Nx)
sumK = sum(allK)
alluniforms = random.uniform(size=2 * sumK)
subresults = subtransitionAndWeight(states[..., indextheta], y, parameters[:, indextheta], alluniforms, allK)
newstates[..., indextheta] = subresults["states"]
weights[..., indextheta] = subresults["weights"]
# --------------
return {"states": newstates, "weights": weights}
modelx = SSM("SV one-factor", xdimension=2, ydimension=1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionAndWeight)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([0.5, 0.0625, 0.01])
"""
#comboKernel = comboKernelTemplate % {"Ntheta": Ntheta}
transitionKernel = transitionKernelTemplate
transitionGF = SourceModule(transitionKernel).get_function("transition")
def transitionCUDA(states, y, parameters, t):
THREADS_PER_BLOCK_X = 16
THREADS_PER_BLOCK_Y = 16
y = array(y, dtype = float32)
states = states.astype(float32)
parameters = parameters.astype(float32)
Nx, statedim, Ntheta = states.shape
noise = random.normal(size = (Nx, Ntheta), loc = 0, scale = 1).astype(float32)
num_blocks_x = int(math.ceil(Nx / THREADS_PER_BLOCK_X))
num_blocks_y = int(math.ceil(Ntheta / THREADS_PER_BLOCK_Y))
transitionGF(drv.In(y), drv.InOut(states), \
drv.In(parameters), \
drv.InOut(noise), \
drv.In(array(Nx, dtype = int32)), \
drv.In(array(Ntheta, dtype = int32)), \
drv.In(array(statedim, dtype = int32)), \
block = (THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y, 1), grid = (num_blocks_x, num_blocks_y))
return {"states": states, "weights": noise}
modelx = SSM(name = "Linear Gaussian model x (using CUDA)", xdimension = 1, ydimension = 1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionCUDA)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([0.8, 0.4])
def transitionCUDA(states, y, parameters, t):
THREADS_PER_BLOCK_X = 16
THREADS_PER_BLOCK_Y = 16
y = array(y, dtype=float32)
states = states.astype(float32)
parameters = parameters.astype(float32)
Nx, statedim, Ntheta = states.shape
noise = random.normal(size=(Nx, Ntheta), loc=0, scale=1).astype(float32)
num_blocks_x = int(math.ceil(Nx / THREADS_PER_BLOCK_X))
num_blocks_y = int(math.ceil(Ntheta / THREADS_PER_BLOCK_Y))
transitionGF(drv.In(y), drv.InOut(states), \
drv.In(parameters), \
drv.InOut(noise), \
drv.In(array(t, dtype = float32)), \
drv.In(array(Nx, dtype = int32)), \
drv.In(array(Ntheta, dtype = int32)), \
drv.In(array(statedim, dtype = int32)), \
block = (THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y, 1), grid = (num_blocks_x, num_blocks_y))
return {"states": states, "weights": noise}
modelx = SSM(name="Periodic Gaussian model x (using CUDA)",
xdimension=1,
ydimension=1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionCUDA)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([10, 1])
transitionGF = SourceModule(transitionKernel).get_function("transition")
def transitionCUDA(states, y, parameters, t):
THREADS_PER_BLOCK_X = 16
THREADS_PER_BLOCK_Y = 16
y = array(y, dtype = float32)
states = states.astype(float32)
parameters = parameters.astype(float32)
Nx, statedim, Ntheta = states.shape
noise = random.normal(size = (Nx, Ntheta), loc = 0, scale = 1).astype(float32)
num_blocks_x = int(math.ceil(Nx / THREADS_PER_BLOCK_X))
num_blocks_y = int(math.ceil(Ntheta / THREADS_PER_BLOCK_Y))
transitionGF(drv.In(y), drv.InOut(states), \
drv.In(parameters), \
drv.InOut(noise), \
drv.In(array(Nx, dtype = int32)), \
drv.In(array(Ntheta, dtype = int32)), \
drv.In(array(statedim, dtype = int32)), \
block = (THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y, 1), grid = (num_blocks_x, num_blocks_y))
return {"states": states, "weights": noise}
modelx = SSM("Population Dynamic model x (M2), reparameterized (using CUDA)", xdimension = 1, ydimension = 1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionCUDA)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([0.05**2, 0.05**2, log(1), 0.18, 1, 0.2])
def transitionCUDA(states, y, parameters, t):
THREADS_PER_BLOCK_X = 16
THREADS_PER_BLOCK_Y = 16
y = array(y, dtype=float32)
states = states.astype(float32)
parameters = parameters.astype(float32)
Nx, statedim, Ntheta = states.shape
noise = random.normal(size=(Nx, Ntheta), loc=0, scale=1).astype(float32)
num_blocks_x = int(math.ceil(Nx / THREADS_PER_BLOCK_X))
num_blocks_y = int(math.ceil(Ntheta / THREADS_PER_BLOCK_Y))
transitionGF(drv.In(y), drv.InOut(states), \
drv.In(parameters), \
drv.InOut(noise), \
drv.In(array(Nx, dtype = int32)), \
drv.In(array(Ntheta, dtype = int32)), \
drv.In(array(statedim, dtype = int32)), \
block = (THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y, 1), grid = (num_blocks_x, num_blocks_y))
return {"states": states, "weights": noise}
modelx = SSM("Population Dynamic model x (M2), reparameterized (using CUDA)",
xdimension=1,
ydimension=1)
modelx.setFirstStateGenerator(firstStateGenerator)
modelx.setObservationGenerator(observationGenerator)
modelx.setTransitionAndWeight(transitionCUDA)
# Values used to generate the synthetic dataset when needed:
# (untransformed parameters)
modelx.parameters = array([0.05**2, 0.05**2, log(1), 0.18, 1, 0.2])
