def test_cuda_categorical():
# Construct a minimal SPN
c1 = Categorical(p=[0.35, 0.55, 0.1], scope=0)
c2 = Categorical(p=[0.25, 0.625, 0.125], scope=1)
c3 = Categorical(p=[0.5, 0.2, 0.3], scope=2)
c4 = Categorical(p=[0.6, 0.15, 0.25], scope=3)
c5 = Categorical(p=[0.7, 0.11, 0.19], scope=4)
c6 = Categorical(p=[0.8, 0.14, 0.06], scope=5)
p = Product(children=[c1, c2, c3, c4, c5, c6])
# Randomly sample input values.
inputs = np.column_stack((
np.random.randint(3, size=30),
np.random.randint(3, size=30),
np.random.randint(3, size=30),
np.random.randint(3, size=30),
np.random.randint(3, size=30),
np.random.randint(3, size=30),
)).astype("float64")
if not CUDACompiler.isAvailable():
print("Test not supported by the compiler installation")
return 0
# Execute the compiled Kernel.
results = CUDACompiler().log_likelihood(p, inputs, supportMarginal=False)
# Compute the reference results using the inference from SPFlow.
reference = log_likelihood(p, inputs)
reference = reference.reshape(30)
# Check the computation results against the reference
# Check in normal space if log-results are not very close to each other.
assert np.all(np.isclose(results, reference)) or np.all(
np.isclose(np.exp(results), np.exp(reference)))
def test_cpu_histogram():
# Construct a minimal SPN.
h1 = Histogram([0., 1., 2.], [0.25, 0.75], [1, 1], scope=0)
h2 = Histogram([0., 3., 6., 8.], [0.35, 0.1, 0.55], [1, 1], scope=1)
h3 = Histogram([0., 1., 2.], [0.33, 0.67], [1, 1], scope=0)
h4 = Histogram([0., 5., 8.], [0.875, 0.125], [1, 1], scope=1)
p0 = Product(children=[h1, h2])
p1 = Product(children=[h3, h4])
spn = Sum([0.3, 0.7], [p0, p1])
inputs = np.column_stack((
np.random.randint(2, size=30),
np.random.randint(8, size=30),
)).astype("float64")
# Insert some NaN in random places into the input data.
inputs.ravel()[np.random.choice(inputs.size, 5, replace=False)] = np.nan
if not CUDACompiler.isAvailable():
print("Test not supported by the compiler installation")
return 0
# Execute the compiled Kernel.
results = CUDACompiler().log_likelihood(spn, inputs)
# Compute the reference results using the inference from SPFlow.
reference = log_likelihood(spn, inputs)
reference = reference.reshape(30)
# Check the computation results against the reference
# Check in normal space if log-results are not very close to each other.
assert np.all(np.isclose(results, reference)) or np.all(
np.isclose(np.exp(results), np.exp(reference)))
def test_cuda_NIPS5():
# Locate test resources located in same directory as this script.
scriptPath = os.path.realpath(os.path.dirname(__file__))
# Deserialize model
query = BinaryDeserializer(os.path.join(scriptPath, "NIPS5.bin")).deserialize_from_file()
spn = query.graph.root
inputs = np.genfromtxt(os.path.join(scriptPath, "inputdata.txt"), delimiter=";", dtype="int32")
# Execute the compiled Kernel.
results = CUDACompiler(computeInLogSpace=False).log_likelihood(spn, inputs, supportMarginal=False)
# Compute the reference results using the inference from SPFlow.
reference = np.genfromtxt(os.path.join(scriptPath, "outputdata.txt"), delimiter=";", dtype="float64")
reference = reference.reshape(10000)
# Check the computation results against the reference
# Check in normal space if log-results are not very close to each other.
assert np.all(np.isclose(results, reference)) or np.all(np.isclose(np.exp(results), np.exp(reference)))
def test_cuda_marginal_gaussian():
# Construct a minimal SPN using two Gaussian leaves.
g1 = Gaussian(mean=0.5, stdev=1, scope=0)
g2 = Gaussian(mean=0.125, stdev=0.25, scope=1)
g3 = Gaussian(mean=0.345, stdev=0.24, scope=2)
g4 = Gaussian(mean=0.456, stdev=0.1, scope=3)
g5 = Gaussian(mean=0.94, stdev=0.48, scope=4)
g6 = Gaussian(mean=0.56, stdev=0.42, scope=5)
g7 = Gaussian(mean=0.76, stdev=0.14, scope=6)
g8 = Gaussian(mean=0.32, stdev=0.8, scope=7)
g9 = Gaussian(mean=0.58, stdev=0.9, scope=8)
g10 = Gaussian(mean=0.14, stdev=0.2, scope=9)
p = Product(children=[g1, g2, g3, g4, g5, g6, g7, g8, g9, g10])
# Randomly sample input values from the two Gaussian (normal) distributions.
inputs = np.column_stack((np.random.normal(0.5, 1, 30),
np.random.normal(0.125, 0.25, 30),
np.random.normal(0.345, 0.24, 30),
np.random.normal(0.456, 0.1, 30),
np.random.normal(0.94, 0.48, 30),
np.random.normal(0.56, 0.42, 30),
np.random.normal(0.76, 0.14, 30),
np.random.normal(0.32, 0.8, 30),
np.random.normal(0.58, 0.9, 30),
np.random.normal(0.14, 0.2, 30))).astype("float32")
inputs.ravel()[np.random.choice(inputs.size, 15, replace=False)] = np.nan
if not CUDACompiler.isAvailable():
print("Test not supported by the compiler installation")
return 0
# Execute the compiled Kernel.
results = CUDACompiler().log_likelihood(p, inputs)
# Compute the reference results using the inference from SPFlow.
reference = log_likelihood(p, inputs)
reference = reference.reshape(30)
# Check the computation results against the reference
# Check in normal space if log-results are not very close to each other.
assert np.all(np.isclose(results, reference)) or np.all(np.isclose(np.exp(results), np.exp(reference)))