def overwrite_plot_spn(spn, plotfile):
import os
try:
os.remove(plotfile)
except OSError as err:
pass
plot_spn(spn, plotfile)
def plot():
spn = create_SPN()
spn_marg = marginalize()
from spn.io.Graphics import plot_spn
plot_spn(spn, "basicspn.png")
plot_spn(spn_marg, "marginalspn.png")
def run_oSLRAU(dataset, update_after_no_min_batches, prune_after):
data = get_data(dataset)
data = np.where(np.isnan(data),
np.ma.array(data, mask=np.isnan(data)).mean(axis=0), data)
from sklearn.model_selection import train_test_split
train_data, test_data = train_test_split(data,
test_size=0.33,
random_state=42)
# make first mini_batch from data
mini_batch_size = 50
first_mini_batch = data[0:mini_batch_size]
n = first_mini_batch.shape[1] # num of variables
print(n)
context = [Gaussian] * n
ds_context = Context(
parametric_types=context).add_domains(first_mini_batch)
# Learn initial spn
spn = learn_parametric(first_mini_batch, ds_context)
plot_spn(spn, 'intitial_spn.pdf')
print(np.mean(log_likelihood(spn, test_data)))
oSLRAU_params = oSLRAUParams(mergebatch_threshold=128,
corrthresh=0.1,
mvmaxscope=1,
equalweight=True,
currVals=True)
no_of_minibatches = int(data.shape[0] / mini_batch_size)
# update using oSLRAU
for i in range(1, no_of_minibatches):
mini_batch = data[i * mini_batch_size:(i + 1) * mini_batch_size]
update_structure = False
if update_after_no_min_batches // i == 0:
print(i)
update_structure = True
spn = oSLRAU(spn, mini_batch, oSLRAU_params, update_structure)
if i == prune_after:
spn = Prune_oSLRAU(spn)
print(np.mean(log_likelihood(spn, test_data)))
plot_spn(spn, 'final_spn.pdf')
def _fit(self, var_types=None, **kwargs):
if self._spn_type == None:
raise Exception("No SPN-type provided")
if var_types != None:
self.var_types = var_types
else:
var_types = self.var_types
df = self.data.copy()
# Exchange all object columns for their codes as SPFLOW cannot deal with Strings
for key, value in self._categorical_variables.items():
df[key] = value['categorical'].codes
self._nameToVarType = var_types
# Check if variable types are given
if self._nameToVarType is None:
raise ValueError("missing argument 'var_types'")
self._initial_names = self.names.copy()
self._initial_names_count = len(self._initial_names)
self._initial_names_to_index = {
self._initial_names[i]: i
for i in range(self._initial_names_count)
}
# Initialize _state_mask with np.nan
self._state_mask = np.array([
np.nan for i in self._initial_names
]).reshape(-1, self._initial_names_count).astype(float)
# Initialize _condition with np.nan
self._condition = np.repeat(np.nan, self._initial_names_count).reshape(
-1, self._initial_names_count).astype(float)
self._marginalized = set()
self._conditioned = set()
try:
var_types = [self._nameToVarType[name] for name in self.names]
except KeyError as err:
raise ValueError(
'missing var type information for dimension: {}.'.format(
err.args[0]))
if self._spn_type == 'spn':
context = Context(parametric_types=var_types).add_domains(
df.values)
self._spn = learn_parametric(df.values, context)
elif self._spn_type == 'mspn':
context = Context(meta_types=var_types).add_domains(df.values)
self._spn = learn_mspn(df.values, context)
else:
raise Exception("Type of SPN not known: " + self._spn_type)
# TODO: DEBUG OUTPUT for NIPS2020
if self._spn:
plot_spn(self._spn,
fname=Path(
f"../../bin/experiments/spn_graphs/{self.name}.pdf"))
plot_spn_to_svg(
self._spn,
fname=Path(
f"../../bin/experiments/spn_graphs/{self.name}.svg"))
return self._unbound_updater,
dataOut = blocked_images[i + 1]
# assert data.shape[1] == dataIn.shape[1] + dataOut.shape[1], 'invalid column size'
# assert data.shape[0] == dataIn.shape[0] == dataOut.shape[0], 'invalid row size'
ds_context = Context(meta_types=[MetaType.DISCRETE] * dataOut.shape[1])
ds_context.add_domains(dataOut)
ds_context.parametric_types = [Conditional_Poisson] * dataOut.shape[1]
scope = list(range(dataOut.shape[1]))
cspn = learn_conditional(np.concatenate((dataOut, dataIn), axis=1),
ds_context,
scope,
min_instances_slice=0.3 * len(data))
cspn_army.append(cspn)
plot_spn(cspn, "basicspn%s.png" % i)
fileObject = open(path + "/cspn_block%s" % i, "wb")
pickle.dump(cspn, fileObject)
fileObject.close()
from spn.structure.leaves.conditional.Sampling import add_conditional_sampling_support
add_conditional_inference_support()
add_conditional_sampling_support()
from numpy.random.mtrand import RandomState
from spn.algorithms.Sampling import sample_instances
num_samples = 30
num_half_image_pixels = downscaleto * downscaleto // 4
g1 = Gaussian(1, 1, scope=3) g2 = Gaussian(1, 1, scope=5) g3 = Gaussian(1, 1, scope=1) g4 = Gaussian(1, 1, scope=4) g5 = Gaussian(1, 1, scope=2) g6 = Gaussian(1, 1, scope=6) p11 = Product([g1, g2]) p12 = Product([g1, g2]) p13 = Product([g1, g2]) p21 = Product([g3, g4]) p22 = Product([g3, g4]) p23 = Product([g3, g4]) p31 = Product([g5, g6]) p32 = Product([g5, g6]) p33 = Product([g5, g6]) s1 = Sum([0.33, 0.33, 0.33], [p11, p12, p13]) s2 = Sum([0.33, 0.33, 0.33], [p21, p22, p23]) s3 = Sum([0.33, 0.33, 0.33], [p31, p32, p33]) root = Product([s1, s2, s3]) assign_ids(root) rebuild_scopes_bottom_up(root) import matplotlib.pyplot as plt fig = plt.figure(figsize=(12, 6), dpi=180) plot_spn(root, "spn.png")
0] # data[:, :horizontal_middle, :vertical_middle].reshape(len(data), -1)
dataOut = blocked_images[
1] # data[:, :horizontal_middle, vertical_middle:].reshape(len(data), -1)
ds_context = Context(meta_types=[MetaType.REAL] * dataOut.shape[1])
ds_context.add_domains(dataOut)
ds_context.parametric_types = [Conditional_Poisson] * dataOut.shape[1]
scope = list(range(dataOut.shape[1]))
print(np.shape(dataIn), np.shape(dataOut))
cspn = learn_conditional(np.concatenate((dataOut, dataIn), axis=1),
ds_context,
scope,
min_instances_slice=0.4 * len(data))
plot_spn(cspn, "basicspn.png")
# start sampling
from spn.structure.leaves.conditional.Sampling import add_conditional_sampling_support
add_conditional_inference_support()
add_conditional_sampling_support()
from numpy.random.mtrand import RandomState
from spn.algorithms.Sampling import sample_instances
num_samples = 30
num_half_image_pixels = downscaleto * downscaleto // 4
samples_placeholder = np.array([[np.nan] * num_half_image_pixels] *
num_samples).reshape(
-1, num_half_image_pixels)
'''
Created on March 29, 2018
@author: Alejandro Molina
'''
from spn.leaves.Histograms import Histogram_str_to_spn
from spn.experiments.FPGA.GenerateSPNs import fpga_count_ops
from spn.io.Graphics import plot_spn
from spn.io.Text import str_to_spn
if __name__ == '__main__':
with open('../experiments/FPGA/spns/NIPS_30/eqq.txt', 'r') as myfile:
eq = myfile.read()
with open('../experiments/FPGA/spns/NIPS_30/all_data.txt', 'r') as myfile:
words = myfile.readline().strip()
words = words[2:]
words = words.split(';')
print(words)
spn = str_to_spn(eq, words, Histogram_str_to_spn)
print(spn)
print(fpga_count_ops(spn))
plot_spn(spn)
def plot(self, name='images/spn.png'):
plot_spn(self.spn, name)
0] #data[:, :horizontal_middle, :vertical_middle].reshape(len(data), -1)
dataOut = blocked_images[
1] #data[:, :horizontal_middle, vertical_middle:].reshape(len(data), -1)
ds_context = Context(meta_types=[MetaType.REAL] * dataOut.shape[1])
ds_context.add_domains(dataOut)
ds_context.parametric_types = [Conditional_Poisson] * dataOut.shape[1]
scope = list(range(dataOut.shape[1]))
print(np.shape(dataIn), np.shape(dataOut))
cspn = learn_conditional(np.concatenate((dataOut, dataIn), axis=1),
ds_context,
scope,
min_instances_slice=0.4 * len(data))
plot_spn(cspn, 'basicspn.png')
# start sampling
from spn.structure.leaves.conditional.Sampling import add_conditional_sampling_support
add_conditional_inference_support()
add_conditional_sampling_support()
from numpy.random.mtrand import RandomState
from spn.algorithms.Sampling import sample_instances
num_samples = 30
num_half_image_pixels = downscaleto * downscaleto // 4
samples_placeholder = np.array([[np.nan] * num_half_image_pixels] *
num_samples).reshape(
-1, num_half_image_pixels)
top_left_samples = sample_instances(spn, samples_placeholder,
RandomState(123))
return expectation
if __name__ == '__main__':
data, feature_types = generate_gender_age_data(1000, 0)
#Set identity_numeric=False, if you want to use PWLs
spn_params = generate_spn_parameters(identity_numeric=True)
root_node = build_spn(data, feature_types, spn_params, np.random.RandomState(1))
from spn.io.Graphics import plot_spn
plot_spn(root_node, "spn.pdf")
#Import nodes
from spn.experiments.AQP.leaves.identity.IdentityNumeric import IdentityNumeric
from spn.structure.leaves.piecewise.PiecewiseLinear import PiecewiseLinear
from spn.structure.leaves.parametric.Parametric import Categorical
from spn.structure.Base import Sum, Product
#Import conditions
from spn.experiments.AQP.Ranges import NominalRange, NumericRange
#Import inference
from spn.algorithms import Inference
from spn.algorithms.Inference import sum_likelihood, prod_likelihood
def run_rspn(dataset, num_variables, num_latent_variables, num_latent_values,
unroll, oSLRAU_params, update_after_no_min_batches, full_update,
update_leaves, len_sequence_varies):
data = get_data(dataset)
from sklearn.model_selection import train_test_split
train_data, test_data = train_test_split(data,
test_size=0.33,
random_state=42)
print("train:", len(train_data))
print("test:", len(test_data))
rspn = RSPN(num_variables=num_variables,
num_latent_variables=num_latent_variables,
num_latent_values=num_latent_values)
# make first mini_batch from data
mini_batch_size = 10
first_mini_batch = train_data[0:mini_batch_size]
dat = first_mini_batch
dat = dat[:, 0:num_variables]
n = dat.shape[1] # num of variables in each time step
print(n)
context = [Gaussian] * n
ds_context = Context(parametric_types=context).add_domains(
first_mini_batch[:, 0:num_variables])
spn, initial_template_spn, top_spn = rspn.build_initial_template(
first_mini_batch, ds_context, len_sequence_varies)
plot_spn(spn, 'rspn_initial_spn.pdf')
plot_spn(initial_template_spn, 'rspn_initial_template_spn.pdf')
plot_spn(top_spn, 'rspn_top_spn.pdf')
print(np.mean(rspn.log_likelihood(test_data, unroll, len_sequence_varies)))
# Determine number of mini batches
if not len_sequence_varies:
no_of_minibatches = int(train_data.shape[0] / mini_batch_size)
else:
no_of_minibatches = int(len(train_data) / mini_batch_size)
for i in range(1, no_of_minibatches):
mini_batch = train_data[i * mini_batch_size:(i + 1) * mini_batch_size]
update_template = False
if i % update_after_no_min_batches == 0:
print(i)
update_template = True
template_spn = rspn.learn_rspn(mini_batch, update_template,
oSLRAU_params, unroll, full_update,
update_leaves, len_sequence_varies)
plot_spn(template_spn, 'rspn_final_template.pdf')
print(np.mean(rspn.log_likelihood(test_data, unroll, len_sequence_varies)))
unrolled_rspn_full = rspn.get_unrolled_rspn(rspn.get_len_sequence())
plot_spn(unrolled_rspn_full, 'rspn_unrolled_full.pdf')
unrolled_rspn = rspn.get_unrolled_rspn(2)
plot_spn(unrolled_rspn, 'rspn_unrolled_2.pdf')
import matplotlib.pyplot as plt from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # Prepare data iris = datasets.load_iris() X_train, X_test, y_train, y_test= train_test_split(iris.data, iris.target, test_size = 0.4, random_state = 42) train_data_with_labels = np.insert(X_train, obj=X_train.shape[1], values=y_train, axis=1) test_data_with_labels = np.insert(X_test, obj=X_test.shape[1], values=y_test, axis=1) # Learn SPN context = Context(parametric_types=[Gaussian, Gaussian, Gaussian, Gaussian, Categorical]).add_domains(train_data_with_labels) spn_classification = learn_classifier(train_data_with_labels, context, learn_parametric, 4) # Plot SPN plot_spn(spn_classification, 'images/iris_spn.png') # Predict true_values = np.array(test_data_with_labels[:,-1]) items_to_predict = test_data_with_labels items_to_predict[:, 4] = np.nan predicted_values = mpe(spn_classification, test_data_with_labels) predicted_labels = predicted_values[:, 4] acc = accuracy_score(true_values, predicted_labels) print(acc)
spn_learn_wrapper=learn_parametric,
label_idx=label_idx,
min_instances_slice=min_instances_slice,
threshold=threshold)
spn = optimize_tf(spn, train_data)
duration = time.time() - start_time
print('\033[1mFinished training after %.3f sec.\033[0m' % duration)
# Model performance evaluation
spn_stats = get_structure_stats(spn)
print(spn_stats)
stats_file = open(plot_path + "/spn_stats.txt", "w+")
stats_file.write(spn_stats)
plot_spn(spn, plot_path + "/spn_struct.pdf")
correct_test_preds, pred_test_labels = evaluate_spn_performance(spn, train_samples, train_labels, test_samples,
test_labels, label_idx, stats_file)
stats_file.close()
correct_preds = np.array([test_samples[k] for k in range(0, len(test_samples)) if correct_test_preds[k] != 0])
wrong_preds = np.array([test_samples[k] for k in range(0, len(test_samples)) if correct_test_preds[k] == 0])
# Plot predictions
plt.subplots(figsize=(5, 5))
plt.scatter(correct_preds[:, 0], correct_preds[:, 1], label="Correctly predicted", c="darkgray", s=10)
plt.scatter(wrong_preds[:, 0], wrong_preds[:, 1], label="Wrongly predicted", c="darkred", s=10)
plt.xlabel('x')
plt.ylabel('y')
axes = plt.gca()
axes.set_xlim([0, 128])
from spn.algorithms.Marginalization import marginalize
from spn.structure.leaves.parametric.Parametric import Categorical
from spn.structure.Base import Sum, Product
from spn.structure.Base import assign_ids, rebuild_scopes_bottom_up
spn = 0.4 * (Categorical(p=[0.2, 0.8], scope=0) *
(0.3 * (Categorical(p=[0.3, 0.7], scope=1) *
Categorical(p=[0.4, 0.6], scope=2))
+ 0.7 * (Categorical(p=[0.5, 0.5], scope=1) *
Categorical(p=[0.6, 0.4], scope=2)))) \
+ 0.6 * (Categorical(p=[0.2, 0.8], scope=0) *
Categorical(p=[0.3, 0.7], scope=1) *
Categorical(p=[0.4, 0.6], scope=2))
spn = marginalize(spn, [1,2])
print(to_JSON(spn) + "\n\n\n")
plot_spn(spn, 'spn1.png')
spn2 = Product(children=[Categorical(p=[0.5, 0.5], scope=0), Categorical(p=[0.2, 0.8], scope=2)])
print(to_JSON(spn2))
assign_ids(spn2)
rebuild_scopes_bottom_up(spn2)
plot_spn(spn2, 'basicspn.png')
print(to_JSON(spn2))
def getSpn1():
spn = 0.4 * (Categorical(p=[0.2, 0.8], scope=0) *
(0.3 * (Categorical(p=[0.3, 0.7], scope=1) *
Categorical(p=[0.4, 0.6], scope=2))
+ 0.7 * (Categorical(p=[0.5, 0.5], scope=1) *
Categorical(p=[0.6, 0.4], scope=2)))) \
+ 0.6 * (Categorical(p=[0.2, 0.8], scope=0) *
dataOut = blocked_images[i + 1]
# assert data.shape[1] == dataIn.shape[1] + dataOut.shape[1], 'invalid column size'
# assert data.shape[0] == dataIn.shape[0] == dataOut.shape[0], 'invalid row size'
ds_context = Context(meta_types=[MetaType.DISCRETE] * dataOut.shape[1])
ds_context.add_domains(dataOut)
ds_context.parametric_types = [Conditional_Poisson] * dataOut.shape[1]
scope = list(range(dataOut.shape[1]))
cspn = learn_conditional(np.concatenate((dataOut, dataIn), axis=1),
ds_context,
scope,
min_instances_slice=0.3 * len(data))
cspn_army.append(cspn)
plot_spn(cspn, 'basicspn%s.png' % i)
fileObject = open(path + "/cspn_block%s" % i, 'wb')
pickle.dump(cspn, fileObject)
fileObject.close()
from spn.structure.leaves.conditional.Sampling import add_conditional_sampling_support
add_conditional_inference_support()
add_conditional_sampling_support()
from numpy.random.mtrand import RandomState
from spn.algorithms.Sampling import sample_instances
num_samples = 30
num_half_image_pixels = downscaleto * downscaleto // 4
# block_samples_spn = sample_instances(spn, np.array([[np.nan] * num_half_image_pixels] * num_samples).reshape(-1, num_half_image_pixels), RandomState(123))
annotation_spn = sample_instances(
