PyHierarchicalTsetlinMachineCUDA 0.2.2__tar.gz → 0.2.5__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyHierarchicalTsetlinMachineCUDA
-Version: 0.2.2
+Version: 0.2.5
 Summary: Hierarchical Tsetlin Machine Architecture.
 Home-page: https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/
 Author: Ole-Christoffer Granmo

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -215,10 +215,13 @@ code_update = """
 				int or_group_vote_sum = 0;
 				for (int or_addend = 0; or_addend < number_of_or_group_addends; ++or_addend) {
 					// Aggregate votes from each child node through addition
+
+					int previous_or_group_vote_sum = or_group_vote_sum; 
 					or_group_vote_sum += child_input[or_group_node*number_of_or_group_addends + or_addend];
-					//if (child_input[or_group_node*number_of_or_group_addends + or_addend]) {
-					//	or_group_vote_sum = 1; 
-					//}
+					if (or_group_vote_sum < 0) {
+						printf("OR* OVERFLOW %d -> %d\\n", previous_or_group_vote_sum, or_group_vote_sum);						
+						or_group_vote_sum = previous_or_group_vote_sum;
+					}
 				}
 
 				// Store or group vote sum as node output
@@ -237,7 +240,14 @@ code_update = """
 				int and_group_vote_product = 1;
 				for (int and_factor = 0; and_factor < number_of_and_group_factors; ++and_factor) {
 					// Aggregate votes from each child node through multiplication
+					
+					int previous_and_group_vote_product = and_group_vote_product;
 					and_group_vote_product *= child_input[and_group_node*number_of_and_group_factors + and_factor];
+
+					if (and_group_vote_product < 0) {
+						printf("AND OVERFLOW %d -> %d\\n", previous_and_group_vote_product, and_group_vote_product);						
+						and_group_vote_product = previous_and_group_vote_product;
+					}
 				}
 
 				// Store and group product as node output
@@ -273,11 +283,15 @@ code_update = """
 				int or_alternatives_vote_sum = 0;
 				for (int or_alternative = 0; or_alternative < number_of_or_alternatives; ++or_alternative) {
 					// Aggregate same input or alternatives through summation
+					
+
+					int previous_or_alternatives_vote_sum = or_alternatives_vote_sum;
 					or_alternatives_vote_sum += child_input[or_alternatives_node * number_of_or_alternatives + or_alternative];
 
-					//if (child_input[or_alternatives_node * number_of_or_alternatives + or_alternative]) {
-					//	or_alternatives_vote_sum = 1;
-					//}
+					if (or_alternatives_vote_sum < 0) {
+						printf("OR OVERFLOW %d -> %d\\n", previous_or_alternatives_vote_sum, or_alternatives_vote_sum);
+						or_alternatives_vote_sum = previous_or_alternatives_vote_sum;
+					}
 				}
 
 				// Store vote sum as node output
@@ -483,3 +497,31 @@ code_transform = """
 		}
 	}
 """
+
+code_clauses = """
+	extern "C" __global__ void get_ta_states(const unsigned int* global_ta_state, unsigned int* unpacked_states) {
+		int index = blockIdx.x * blockDim.x + threadIdx.x;
+		int stride = blockDim.x * gridDim.x;
+
+		for (unsigned long long i = index; i < CLAUSES * COMPONENTS * LITERALS_PER_LEAF; i += stride) {
+			unsigned long long clause = i / (COMPONENTS * LITERALS_PER_LEAF);
+			unsigned long long comp   = (i / LITERALS_PER_LEAF) % COMPONENTS;
+			unsigned long long ta_idx = i % LITERALS_PER_LEAF;
+
+			int chunk   = ta_idx / 32;
+			int bit_pos = ta_idx % 32;
+
+			unsigned int state = 0;
+			for (int b = 0; b < STATE_BITS; ++b) {
+				unsigned int plane = global_ta_state[
+					(clause * COMPONENTS * TA_CHUNKS_PER_LEAF * STATE_BITS) +
+					(comp   * TA_CHUNKS_PER_LEAF * STATE_BITS) +
+					(chunk  * STATE_BITS) + b
+				];
+				if (plane & (1U << bit_pos)) state |= (1U << b);
+			}
+
+			unpacked_states[(clause * COMPONENTS * LITERALS_PER_LEAF) + (comp * LITERALS_PER_LEAF) + ta_idx] = state;
+		}
+	}
+"""

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PyHierarchicalTsetlinMachineCUDA/tm.py

@@ -18,6 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from collections import deque
 import numpy as np
 
 import PyHierarchicalTsetlinMachineCUDA.kernels as kernels
@@ -26,6 +27,7 @@ import pycuda.curandom as curandom
 import pycuda.driver as cuda
 import pycuda.autoinit
 from pycuda.compiler import SourceModule
+from pycuda import gpuarray
 
 from time import time
 
@@ -37,11 +39,10 @@ VANILLA_TM = 0
 WEIGHTED_TM = 1
 COALESCED_TM = 2
 
-g = curandom.XORWOWRandomNumberGenerator() 
 
 class CommonTsetlinMachine():
 
-	def __init__(self, number_of_clauses, T, s, q=1.0, hierarchy_structure=None, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, q=1.0, hierarchy_structure=None, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.number_of_clauses = number_of_clauses
 		self.number_of_state_bits = number_of_state_bits
 		self.T = int(T)
@@ -95,6 +96,12 @@ class CommonTsetlinMachine():
 			if (self.hierarchy_structure[d][0] == OR_GROUP or self.hierarchy_structure[d][0] == AND_GROUP):
 				self.number_of_literal_chunks *= self.hierarchy_structure[d][1]
 
+		self.np_rng = np.random.default_rng(seed)
+		if seed is not None:
+			self.cuda_rng = curandom.XORWOWRandomNumberGenerator(seed_getter=lambda N: gpuarray.to_gpu(self.np_rng.integers(1, 2**30, size=N).astype(np.int32)))
+		else:
+			self.cuda_rng = curandom.XORWOWRandomNumberGenerator() 
+
 		self.cuda_modules()
 
 		self.first = True
@@ -151,6 +158,9 @@ class CommonTsetlinMachine():
 		self.prepare_encode_hierarchy = mod_encode.get_function("prepare_encode_hierarchy")
 		self.encode_hierarchy = mod_encode.get_function("encode_hierarchy")
 
+		mod_clauses = SourceModule(parameters + kernels.code_clauses, no_extern_c=True)
+		self.kernel_get_ta_states = mod_clauses.get_function("get_ta_states")
+
 	def encode_X(self, X, encoded_X_hierarchy_gpu):
 		number_of_examples = X.shape[0]
 
@@ -171,8 +181,8 @@ class CommonTsetlinMachine():
 		# GPU memory for accumulating votes, level by level
 		self.hierarchy_votes = []
 		for d in range(1, self.depth):
-			self.hierarchy_votes.append(cuda.mem_alloc(self.number_of_clauses*int(self.hierarchy_size[d])*4))
-		self.hierarchy_votes.append(cuda.mem_alloc(self.number_of_clauses*4))
+			self.hierarchy_votes.append(cuda.mem_alloc(self.number_of_clauses*int(self.hierarchy_size[d])*8))
+		self.hierarchy_votes.append(cuda.mem_alloc(self.number_of_clauses*8))
 
 		# GPU memory for storing hierarchy structure
 		self.hierarchy_structure_factors_gpu = cuda.mem_alloc((self.depth-1)*4)
@@ -236,10 +246,10 @@ class CommonTsetlinMachine():
 		None # To be updated
 
 	def initialize_weights_and_ta_states(self):
-		self.prepare_weights(g.state, np.int32(self.tm_type), np.int32(self.number_of_outputs), self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
+		self.prepare_weights(self.cuda_rng.state, np.int32(self.tm_type), np.int32(self.number_of_outputs), self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
 		cuda.Context.synchronize()
 
-		self.prepare_hierarchy(g.state, np.int32(self.number_of_outputs), self.ta_state_hierarchy_gpu, self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
+		self.prepare_hierarchy(self.cuda_rng.state, np.int32(self.number_of_outputs), self.ta_state_hierarchy_gpu, self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
 		cuda.Context.synchronize()
 
 	def evaluate_hierarchy(self, encoded_X_hierarchy, e):
@@ -351,7 +361,7 @@ class CommonTsetlinMachine():
 				self.update_hierarchy.prepared_call(
 					self.grid,
 					self.block,
-					g.state,
+					self.cuda_rng.state,
 					np.int32(self.number_of_outputs),
 					self.ta_state_hierarchy_gpu,
 					self.clause_weights_gpu,
@@ -371,7 +381,7 @@ class CommonTsetlinMachine():
 					self.update_weights.prepared_call(
 						self.grid,
 						self.block,
-						g.state,
+						self.cuda_rng.state,
 						np.int32(self.tm_type),
 						np.int32(self.number_of_outputs),
 						self.clause_weights_gpu,
@@ -402,9 +412,102 @@ class CommonTsetlinMachine():
 
 		return class_sum
 
+	def get_ta_states(self) -> np.ndarray:
+		"""
+		Get state value for each TA.
+		Returns: Numpy array of shape (number_of_clauses, number_of_clause_components, number_of_literals_per_leaf)
+		"""
+		# Mem Allocation
+		ta_states_gpu = gpuarray.to_gpu(
+			np.zeros((self.number_of_clauses, self.hierarchy_size[1], self.number_of_literals_per_leaf), dtype=np.uint32)
+		)
+
+		# Calculate grid size based on the kernel
+		total = self.number_of_clauses * self.hierarchy_size[1] * self.number_of_literals_per_leaf
+		grid = (((total + self.block[0] - 1) // self.block[0]), 1, 1)
+		self.kernel_get_ta_states(self.ta_state_hierarchy_gpu, ta_states_gpu, block=self.block, grid=grid)
+
+		# Copy back to CPU
+		return ta_states_gpu.get()
+
+	def get_literals(self):
+		"""
+		Get included literals for each clause.
+		Returns: Numpy array of shape (number_of_clauses, number_of_clause_components, number_of_literals_per_leaf)
+		"""
+		return (self.get_ta_states() >= (1 << (self.number_of_state_bits - 1))).astype(np.uint8)
+
+	def map_ta_id_to_feature_id(self):
+		"""
+		Return an array of shape(number_of_clause_components, number_of_literals_per_leaf). That is the total number of TAs in a clause. Maps each TA id to a feature_id in the input. In each component, the first half of the TAs correspond to the positive features, and the second half correspond to the negated features.
+		"""
+		# BFS top-down traversal
+		q = deque()
+		q.append((self.depth - 1, 0, 0)) # (level, node_id, group_id)
+
+		comp_grps = -1 * np.ones(self.hierarchy_size[1], dtype=np.int32)
+		while q:
+			level, node_id, group_id = q.popleft()
+
+			if level == 0:
+				# This is the leaf component
+				comp_grps[node_id] = group_id
+				continue
+
+			n_children = self.hierarchy_structure[level][1]
+			is_alt = (self.hierarchy_structure[level][0] == OR_ALTERNATIVES)
+			for child_pos in range(n_children):
+				child_id = node_id * n_children + child_pos
+				if is_alt:
+					# All children share the same features
+					child_group_id = group_id
+				else:
+					# Features are partitioned among the children
+					child_group_id = group_id * n_children + child_pos
+
+				q.append((level - 1, child_id, child_group_id))
+
+		# map each TA in a component to a feature
+		half = self.number_of_literals_per_leaf // 2
+		lit_ids = np.arange(self.number_of_literals_per_leaf)
+		local_feats = lit_ids % half if self.append_negated else lit_ids
+		fmap = comp_grps[:, None] * (half if self.append_negated else self.number_of_literals_per_leaf) + local_feats[None, :]
+
+		return fmap
+
+	def calc_hierarchy_votes(self, X):
+		"""
+		Get the clause activation information for each sample in X.
+		"""
+		assert not self.first, "Model must be trained before getting activations."
+
+		number_of_examples = X.shape[0]
+		encoded_X_hierarchy_test_gpu = gpuarray.empty((number_of_examples, self.number_of_literal_chunks), dtype=np.uint32)
+		self.encode_X(X, encoded_X_hierarchy_test_gpu.gpudata)
+
+		class_sum = np.ascontiguousarray(np.zeros((self.number_of_outputs, number_of_examples))).astype(np.int32)
+		class_sum_example = np.ascontiguousarray(np.zeros(self.number_of_outputs)).astype(np.int32)
+		hierarchy_votes = []
+		for e in range(number_of_examples):
+			self.evaluate_hierarchy(encoded_X_hierarchy_test_gpu.gpudata, e)
+
+			cuda.memcpy_dtoh(class_sum_example, self.class_sum_gpu)
+			class_sum[:, e] = class_sum_example
+
+			hierarchy_votes_example = []
+			for d in range(self.depth):
+				temp_arr = np.empty(self.number_of_clauses*int(self.hierarchy_size[d+1]), dtype=np.int32)
+				cuda.memcpy_dtoh(temp_arr, self.hierarchy_votes[d])
+				hierarchy_votes_example.append(temp_arr.reshape((self.number_of_clauses, int(self.hierarchy_size[d+1]))))
+
+			hierarchy_votes.append(hierarchy_votes_example)
+		
+		class_sum = np.clip(class_sum.reshape((self.number_of_outputs, number_of_examples)), -self.T, self.T)
+		return hierarchy_votes, class_sum
+
 	def print_hierarchy(self, print_ta_state=False):
 		for i in range(self.number_of_clauses):
-			print("\n CLAUSE #%d: " % (i), end='')
+			print("\nCLAUSE #%d: " % (i), end='')
 
 			previous_index = np.ones((self.depth-1), dtype=np.int32)*-1
 			for j in range(self.hierarchy_size[1]):
@@ -457,11 +560,53 @@ class CommonTsetlinMachine():
 					print(l[0], end = '')
 
 			print(")" * (self.depth - 1))
+
+	def save(self) -> dict:
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.hierarchy_size[0]*self.number_of_state_bits, dtype=np.uint32)
+		cuda.memcpy_dtoh(ta_state_hierarchy, self.ta_state_hierarchy_gpu)
+
+		clause_weights = np.empty(self.number_of_outputs*self.number_of_clauses, dtype=np.int32)
+		cuda.memcpy_dtoh(clause_weights, self.clause_weights_gpu)
+
+		return {
+			'ta_state_hierarchy': ta_state_hierarchy,
+			'clause_weights': clause_weights,
+			'number_of_outputs': self.number_of_outputs,
+			'min_y': self.min_y,
+			'max_y': self.max_y,
+			'params': {
+				'number_of_clauses': self.number_of_clauses,
+				'T': self.T,
+				's': self.s,
+				'q': self.q,
+				'hierarchy_structure': self.hierarchy_structure,
+				'boost_true_positive_feedback': self.boost_true_positive_feedback,
+				'number_of_state_bits': self.number_of_state_bits,
+				'append_negated': self.append_negated,
+			},
+			'negative_clauses': self.negative_clauses,
+			'tm_type': self.tm_type,
+			'flip_polarity': self.flip_polarity,
+			'weighted_clauses': getattr(self, 'weighted_clauses', None),
+		}
+
+	def load(self, state_dict: dict):
+		self.number_of_outputs = state_dict['number_of_outputs']
+		self.min_y = state_dict['min_y']
+		self.max_y = state_dict['max_y']
+
+		self.allocate_gpu_memory()
+
+		cuda.memcpy_htod(self.ta_state_hierarchy_gpu, state_dict['ta_state_hierarchy'])
+		cuda.memcpy_htod(self.clause_weights_gpu, state_dict['clause_weights'])
+
+		self.first = False
+
 	
 class MultiOutputTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.negative_clauses = 1
-		super().__init__(number_of_clauses, T, s, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block)
+		super().__init__(number_of_clauses, T, s, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block, seed=seed)
 
 	def fit(self, X, Y, epochs=100, incremental=False):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -485,12 +630,12 @@ class MultiOutputTsetlinMachine(CommonTsetlinMachine):
 		return (self.score(X) >= 0).astype(np.uint32).transpose()
 
 class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.negative_clauses = 1
 		self.tm_type = COALESCED_TM
 		self.flip_polarity = 1
 
-		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block)
+		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block, seed=seed)
 
 	def fit(self, X, Y, epochs=100, incremental=False):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -517,7 +662,7 @@ class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
 		return np.argmax(self.score(X), axis=0)
 
 class MultiClassTsetlinMachine:
-	def __init__(self, number_of_clauses, T, s, weighted_clauses=False, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, weighted_clauses=False, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.number_of_clauses = number_of_clauses
 		self.T = T
 		self.s = s
@@ -529,19 +674,20 @@ class MultiClassTsetlinMachine:
 		self.append_negated = append_negated
 		self.grid = grid
 		self.block = block
+		self.seed = np.random.randint(1, 2**30) if seed is None else seed
 
 		self.configured = False
 
 	def fit(self, X, Y, epochs=100, incremental=False):
 		self.number_of_outputs = int(np.max(Y) + 1)
-		
+
 		if not self.configured:
 			self.tms = []
 			for i in range(self.number_of_outputs):
-				self.tms.append(TsetlinMachine(self.number_of_clauses, self.T, self.s, weighted_clauses=self.weighted_clauses, hierarchy_structure=self.hierarchy_structure, q=self.q, boost_true_positive_feedback=self.boost_true_positive_feedback, number_of_state_bits=self.number_of_state_bits, append_negated=self.append_negated, grid=self.grid, block=self.block))
+				self.tms.append(TsetlinMachine(self.number_of_clauses, self.T, self.s, weighted_clauses=self.weighted_clauses, hierarchy_structure=self.hierarchy_structure, q=self.q, boost_true_positive_feedback=self.boost_true_positive_feedback, number_of_state_bits=self.number_of_state_bits, append_negated=self.append_negated, grid=self.grid, block=self.block, seed=self.seed+i))
 
 			self.configured = True
-		
+
 		encoded_Y = np.empty(Y.shape[0], dtype = np.int32)
 
 		for epoch in range(epochs):
@@ -569,8 +715,38 @@ class MultiClassTsetlinMachine:
 	def predict(self, X):
 		return np.argmax(self.score(X), axis=0)
 
+	def save(self) -> dict:
+		return {
+			'number_of_outputs': self.number_of_outputs,
+			'tms': [t.save() for t in self.tms],
+			'params': {
+				'number_of_clauses': self.number_of_clauses,
+				'T': self.T,
+				's': self.s,
+				'q': self.q,
+				'weighted_clauses': self.weighted_clauses,
+				'hierarchy_structure': self.hierarchy_structure,
+				'boost_true_positive_feedback': self.boost_true_positive_feedback,
+				'number_of_state_bits': self.number_of_state_bits,
+				'append_negated': self.append_negated,
+				'grid': self.grid,
+				'block': self.block,
+			},
+		}
+
+	def load(self, state_dict: dict):
+		self.number_of_outputs = state_dict['number_of_outputs']
+
+		self.tms = []
+		for tm_state in state_dict['tms']:
+			t = TsetlinMachine(self.number_of_clauses, self.T, self.s, weighted_clauses=self.weighted_clauses, hierarchy_structure=self.hierarchy_structure, q=self.q, boost_true_positive_feedback=self.boost_true_positive_feedback, number_of_state_bits=self.number_of_state_bits, append_negated=self.append_negated, grid=self.grid, block=self.block)
+			t.load(tm_state)
+			self.tms.append(t)
+
+		self.configured = True
+
 class TsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, weighted_clauses=False, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, weighted_clauses=False, hierarchy_structure=((AND_GROUP, 1)), q=1.0, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.negative_clauses = 1
 		self.flip_polarity = 0
 
@@ -579,7 +755,7 @@ class TsetlinMachine(CommonTsetlinMachine):
 		else:
 			self.tm_type = VANILLA_TM
 
-		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block)
+		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, q=q, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block, seed=seed)
 
 	def fit(self, X, Y, epochs=100, incremental=False):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -603,11 +779,11 @@ class TsetlinMachine(CommonTsetlinMachine):
 		return (self.score(X) >= 0).astype(np.int32)
 
 class RegressionTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, hierarchy_structure=((AND_GROUP, 1)), boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+	def __init__(self, number_of_clauses, T, s, hierarchy_structure=((AND_GROUP, 1)), boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
 		self.negative_clauses = 0
 		self.flip_polarity = 0
 
-		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block)
+		super().__init__(number_of_clauses, T, s, hierarchy_structure=hierarchy_structure, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block, seed=seed)
 
 	def fit(self, X, Y, epochs=100, incremental=False):
 		X = X.reshape(X.shape[0], X.shape[1], 1)

PyHierarchicalTsetlinMachineCUDA-0.2.5/PyHierarchicalTsetlinMachineCUDA/utils.py

@@ -0,0 +1,175 @@
+from collections import deque
+
+import networkx as nx
+import numpy as np
+
+from .tm import OR_ALTERNATIVES, CommonTsetlinMachine
+
+
+def make_hierarchy_graph(G: nx.Graph, hier: list[tuple[int, int]]):
+	"""Create Graph from the hierarchy."""
+	# BFS
+	q = deque()
+	q.append((len(hier), 0))  # (level, idx)
+	while q:
+		level, idx = q.popleft()
+		G.add_node((level, idx), label=hier[level - 1][0], op=hier[level - 1][0])
+		if level == 1:
+			continue
+		branching = hier[level - 1][1]
+		for cid in range(idx * branching, (idx + 1) * branching):
+			q.append((level - 1, cid))
+			G.add_edge((level, idx), (level - 1, cid))
+
+
+def clause_to_nx(
+	tm: CommonTsetlinMachine,
+	clause_idx: int,
+	feature_names: list[str] | None = None,
+	negation_prefix: str = '¬',
+	clause_literals: np.ndarray | None = None,
+	ta_to_fid_mapping=None,
+):
+	"""
+	Create a networkx Graph for a single clause.
+	Args:
+		`tm`: The model.
+		`clause_idx`: Index of the clause to visualize.
+		`feature_names`: Optional list of feature names for labeling. If None, defaults to 'x0', 'x1', ...
+		`negation_prefix`: Prefix for negated features (default: '¬').
+		`clause_literals`: Optional pre-extracted literals for the clause, must have shape (n_components, literals_per_component). If None, literals will be extracted from the model.
+		`ta_to_fid_mapping`: Optional mapping from (component_id, literal_id) to feature_id. If None, it will be obtained from the model.
+	"""
+
+	assert tm.hierarchy_structure is not None, (
+		'Hierarchy structure not defined in the model. Are you sure tm belongs to CommonTsetlinMachine or its subclasses?'
+	)
+
+	if feature_names is None:
+		feature_names = [f'x{i}' for i in range(tm.number_of_features_hierarchy)]
+
+	literals = (
+		clause_literals
+		if clause_literals is not None
+		else tm.get_literals()[clause_idx]
+	)
+	ta_to_fid = (
+		ta_to_fid_mapping
+		if ta_to_fid_mapping is not None
+		else tm.map_ta_id_to_feature_id()
+	)
+	n_comp = tm.hierarchy_size[1]
+	lits_per_comp = tm.number_of_literals_per_leaf
+
+	G = nx.Graph()
+	make_hierarchy_graph(G, tm.hierarchy_structure)
+
+	feat_per_comp = lits_per_comp // 2 if tm.append_negated else lits_per_comp
+
+	# Add included literals to leaf components
+	for comp_id in range(n_comp):
+		for fid in range(feat_per_comp):
+			pos_lit = literals[comp_id, fid]
+			if pos_lit:
+				G.add_node(
+					(0, comp_id * lits_per_comp + fid),
+					label=feature_names[ta_to_fid[comp_id, fid]],
+				)
+				G.add_edge((1, comp_id), (0, comp_id * lits_per_comp + fid))
+
+			if tm.append_negated:
+				neg_lit = literals[comp_id, feat_per_comp + fid]
+				if neg_lit:
+					lab = f'{negation_prefix}{feature_names[ta_to_fid[comp_id, fid]]}'
+					G.add_node(
+						(0, comp_id * lits_per_comp + feat_per_comp + fid), label=lab
+					)
+					G.add_edge(
+						(1, comp_id), (0, comp_id * lits_per_comp + feat_per_comp + fid)
+					)
+
+	return G
+
+
+def clause_bank_to_nx(
+	tm: CommonTsetlinMachine,
+	feature_names: list[str] | None = None,
+	negation_prefix: str = '¬',
+):
+	"""
+	Create a networkx Graph for the entire clause bank.
+	Args:
+		`tm`: The model.
+		`feature_names`: Optional list of feature names for labeling. If None, defaults to 'x0', 'x1', ...
+		`negation_prefix`: Prefix for negated features (default: '¬').
+	"""
+	literals = tm.get_literals()
+	ta_to_fid = tm.map_ta_id_to_feature_id()
+	G = nx.Graph()
+	cb_root = 'CB_ROOT'
+	G.add_node(cb_root, label=OR_ALTERNATIVES, op=OR_ALTERNATIVES)
+	for ci in range(tm.number_of_clauses):
+		clause_G = clause_to_nx(
+			tm, ci, feature_names, negation_prefix, literals[ci], ta_to_fid
+		)
+		mapping = {node: (ci, node) for node in clause_G.nodes}
+		G = nx.compose(G, nx.relabel_nodes(clause_G, mapping))
+		G.add_edge(cb_root, (ci, (tm.depth, 0)))
+
+	return G
+
+
+def active_path_graph(
+	tm: CommonTsetlinMachine,
+	X: np.ndarray,
+	feature_names: list[str] | None = None,
+	negation_prefix: str = '¬',
+):
+	"""
+	Show the activated path, and vote calculation for a single sample `X`.
+	Args:
+		`tm`: The model.
+		`X`: A single sample with shape (n_features,).
+		`feature_names`: Optional list of feature names for labeling. If None, defaults to 'x0', 'x1', ...
+		`negation_prefix`: Prefix for negated features (default: '¬').
+	Returns:
+		A list of networkx Graphs for each clause, with 'active' and 'vote' attributes on nodes and edges, and class sums for each class.
+	"""
+	assert X.ndim == 1, 'X must be a single sample with shape (n_features,)'
+
+	hierarchy_votes, class_sums = tm.calc_hierarchy_votes(X.reshape(1, -1))
+	hierarchy_votes = hierarchy_votes[0]
+	class_sums = class_sums[0]
+
+	literals = tm.get_literals()
+	ta_to_fid = tm.map_ta_id_to_feature_id()
+	lits_per_comp = tm.number_of_literals_per_leaf
+	feat_per_comp = lits_per_comp // 2 if tm.append_negated else lits_per_comp
+
+	G = [
+		clause_to_nx(tm, ci, feature_names, negation_prefix, literals[ci], ta_to_fid)
+		for ci in range(tm.number_of_clauses)
+	]
+	for ci in range(tm.number_of_clauses):
+		g = G[ci]
+
+		for node in g.nodes():
+			level, idx = node
+			if level == 0:
+				comp_id = idx // lits_per_comp
+				local_lit = idx % lits_per_comp
+				fid = ta_to_fid[comp_id, local_lit]
+				is_neg = (local_lit >= feat_per_comp) if tm.append_negated else False
+				g.nodes[node]['active'] = (X[fid] == 0) if is_neg else (X[fid] == 1)
+				g.nodes[node]['vote'] = 1 if g.nodes[node]['active'] else None
+			else:
+				vote = hierarchy_votes[level - 1][ci, idx]
+				g.nodes[node]['active'] = vote > 0
+				g.nodes[node]['vote'] = vote
+
+		for u, v in g.edges():
+			g.edges[u, v]['active'] = g.nodes[u].get('active', False) and g.nodes[
+				v
+			].get('active', False)
+
+	return G, class_sums

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyHierarchicalTsetlinMachineCUDA
-Version: 0.2.2
+Version: 0.2.5
 Summary: Hierarchical Tsetlin Machine Architecture.
 Home-page: https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/
 Author: Ole-Christoffer Granmo

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PyHierarchicalTsetlinMachineCUDA.egg-info/SOURCES.txt

@@ -5,12 +5,9 @@ PyHierarchicalTsetlinMachineCUDA/__init__.py
 PyHierarchicalTsetlinMachineCUDA/kernels.py
 PyHierarchicalTsetlinMachineCUDA/tm.py
 PyHierarchicalTsetlinMachineCUDA/tools.py
+PyHierarchicalTsetlinMachineCUDA/utils.py
 PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO
 PyHierarchicalTsetlinMachineCUDA.egg-info/SOURCES.txt
 PyHierarchicalTsetlinMachineCUDA.egg-info/dependency_links.txt
 PyHierarchicalTsetlinMachineCUDA.egg-info/requires.txt
-PyHierarchicalTsetlinMachineCUDA.egg-info/top_level.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/PKG-INFO
-pyhierarchicaltsetlinmachinecuda.egg-info/SOURCES.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/dependency_links.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/top_level.txt
+PyHierarchicalTsetlinMachineCUDA.egg-info/top_level.txt

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/PyHierarchicalTsetlinMachineCUDA.egg-info/requires.txt

@@ -2,6 +2,9 @@ numpy
 pycuda
 scipy
 scikit-learn
+networkx
 
 [examples]
 tensorflow
+matplotlib
+pygraphviz

PyHierarchicalTsetlinMachineCUDA-0.2.5/README.md

@@ -0,0 +1,192 @@
+# Hierarchical Tsetlin Machine in CUDA
+Implements the [Hierarchical Tsetlin Machine](https://github.com/cair/HierarchicalTsetlinMachine) in CUDA.
+
+<p align="center">
+  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/main/figures/Visualization_voting.png">
+</p>
+
+## Installation
+
+```bash
+pip install PyHierarchicalTsetlinMachineCUDA
+```
+or
+```bash
+git clone git@github.com:cair/PyHierarchicalTsetlinMachineCUDA.git
+cd PyHierarchicalTsetlinMachineCUDA
+python ./setup.py sdist
+pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.2.tar.gz 
+```
+
+## Examples
+
+### Noisy Parity Demo
+
+#### Code: NoisyParityDemo.py
+
+```python
+from PyHierarchicalTsetlinMachineCUDA.tm import TsetlinMachine
+import numpy as np
+from time import time
+import PyHierarchicalTsetlinMachineCUDA.tm as tm
+
+clauses = 32
+s = 25.0
+T = 250
+
+train_data = np.loadtxt("./examples/NoisyParityTrainingData.txt").astype(np.uint32)
+X_train = train_data[:,0:-1]
+Y_train = train_data[:,-1]
+
+test_data = np.loadtxt("./examples/NoisyParityTestingData.txt").astype(np.uint32)
+X_test = test_data[:,0:-1]
+Y_test = test_data[:,-1]
+
+tm = TsetlinMachine(clauses, T, s, number_of_state_bits=8, boost_true_positive_feedback=0, hierarchy_structure=((tm.AND_GROUP, 3), (tm.OR_ALTERNATIVES, 3), (tm.AND_GROUP, 2), (tm.OR_ALTERNATIVES, 3), (tm.AND_GROUP, 2)))
+
+print("\nAccuracy over 1000 epochs:\n")
+for e in range(1000):
+	start_training = time()
+	tm.fit(X_train, Y_train, epochs=10, incremental=True)
+	stop_training = time()
+
+	start_testing = time()
+	result = 100*(tm.predict(X_test) == Y_test).mean()
+	stop_testing = time()
+
+	tm.print_hierarchy()
+
+	print("\n#%d Accuracy: %.2f%% Training: %.2fs Testing: %.2fs" % (e+1, result, stop_training-start_training, stop_testing-start_testing))
+```
+
+#### Output
+
+```bash
+python ./examples/NoisyParityData.py
+python ./examples/NoisyParityDemo.py
+
+Accuracy over 1000 epochs:
+
+#1 Accuracy: 51.19% Training: 21.88s Testing: 1.37s
+#2 Accuracy: 51.94% Training: 21.91s Testing: 1.37s
+#3 Accuracy: 53.46% Training: 21.91s Testing: 1.37s
+...
+CLAUSE 1: (((((x0 ∧ x1) ∨ (x0 ∧ x1) ∨ (¬x0 ∧ ¬x1)) ∧ ((¬x0 ∧ ¬x1) ∨ (x0 ∧ x1) ∨ (x0 ∧ x1))) ∨ (((¬x0 ∧ ¬x1) ∨ (¬x0 ∧ ¬x1) ∨ (x0 ∧ x1)) ∧ ((x0 ∧ x1) ∨ (x0 ∧ x1) ∨ (¬x0 ∧ ¬x1))) ∨ (((x0 ∧ x1) ∨ (x0 ∧ x1) ∨ (¬x0 ∧ ¬x1)) ∧ (¬x0 ∨ (x0 ∧ x1) ∨ (¬x0 ∧ ¬x1)))) ∧ ((((x0 ∧ ¬x1) ∨ (x0 ∧ ¬x1) ∨ (x1 ∧ ¬x0)) ∧ ((x0 ∧ x1) ∨ (¬x0 ∧ ¬x1) ∨ (¬x0 ∧ ¬x1))) ∨ (((x1 ∧ ¬x0) ∨ (x0 ∧ ¬x1) ∨ (x0 ∧ ¬x1)) ∧ ((x0 ∧ x1) ∨ (¬x0 ∧ ¬x1) ∨ (x0 ∧ x1))) ∨ (((x1 ∧ ¬x0) ∨ (x1 ∧ ¬x0) ∨ (x0 ∧ ¬x1)) ∧ ((x0 ∧ x1) ∨ (¬x0 ∧ ¬x1) ∨ (¬x0 ∧ ¬x1)))))
+...
+#778 Accuracy: 99.71% Training: 32.57s Testing: 2.18s
+```
+
+### Hex Demo
+
+<p align="center">
+  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/hex_description/figures/Hex-board-11x11.png">
+</p>
+<p align="center">
+Source: https://en.wikipedia.org/wiki/Hex_(board_game)
+</p>
+
+#### Code: HexDemo.py
+
+```python
+from PyHierarchicalTsetlinMachineCUDA.tm import TsetlinMachine
+import numpy as np
+from time import time
+import PyHierarchicalTsetlinMachineCUDA.tm as tm
+import argparse
+
+def default_args(**kwargs):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--epochs", default=1000, type=int)
+    parser.add_argument("--clauses", default=2000, type=int)
+    parser.add_argument("--T", default=9000, type=int)
+    parser.add_argument("--s", default=44.0, type=float)
+    parser.add_argument("--q", default=1.0, type=float)
+    parser.add_argument("--boost", default=1, type=int)
+    parser.add_argument("--number_of_state_bits", default=7, type=int)
+    parser.add_argument("--or_alternatives", default=60, type=int)
+  
+    args = parser.parse_args()
+    for key, value in kwargs.items():
+        if key in args.__dict__:
+            setattr(args, key, value)
+    return args
+
+args = default_args()
+
+data = np.loadtxt("./examples/hex_data.txt").astype(np.uint32)
+X_train = data[:int(len(data)*0.8),0:-1]
+Y_train = data[:int(len(data)*0.8),-1]
+
+X_test = data[int(len(data)*0.8):,0:-1]
+Y_test = data[int(len(data)*0.8):,-1]
+
+tsetlin_machine = TsetlinMachine(args.clauses, args.T, args.s, weighted_clauses=False, number_of_state_bits=args.number_of_state_bits, boost_true_positive_feedback=args.boost, hierarchy_structure=((tm.AND_GROUP, 72), (tm.OR_ALTERNATIVES, args.or_alternatives), (tm.AND_GROUP, 4)))
+
+print("\nAccuracy over %d epochs:\n" % (args.epochs))
+for e in range(args.epochs):
+	start_training = time()
+	for b in range(10):
+		tsetlin_machine.fit(X_train[b*len(Y_train)//10:(b+1)*len(Y_train)//10], Y_train[b*len(Y_train)//10:(b+1)*len(Y_train)//10], epochs=1, incremental=True)
+	stop_training = time()
+
+	start_testing = time()
+	result_testing = 100*(tsetlin_machine.predict(X_test) == Y_test).mean()
+	stop_testing = time()
+
+	result_training = 100*(tsetlin_machine.predict(X_train) == Y_train).mean()
+
+	print("#%d Training Accuracy: %.2f%% Testing Accuracy: %.2f%% Training Time: %.2fs Testing Time: %.2fs" % (e+1, result_training, result_testing, stop_training-start_training, stop_testing-start_testing))
+```
+
+#### Output
+
+```bash
+cd ./examples
+make
+./hex
+cd ..
+python3 ./examples/HexDemo.py
+
+Accuracy over 1000 epochs:
+
+#1 Training Accuracy: 97.71% Testing Accuracy: 97.26% Training Time: 36.00s Testing Time: 5.65s
+#2 Training Accuracy: 99.11% Testing Accuracy: 98.61% Training Time: 33.65s Testing Time: 5.65s
+#3 Training Accuracy: 99.53% Testing Accuracy: 98.92% Training Time: 33.00s Testing Time: 5.65s
+#4 Training Accuracy: 99.74% Testing Accuracy: 99.18% Training Time: 32.66s Testing Time: 5.67s
+#5 Training Accuracy: 99.84% Testing Accuracy: 99.35% Training Time: 32.40s Testing Time: 5.67s
+...
+#446 Training Accuracy: 100.00% Testing Accuracy: 99.45% Training Time: 32.09s Testing Time: 6.09s
+#447 Training Accuracy: 100.00% Testing Accuracy: 99.46% Training Time: 32.08s Testing Time: 6.09s
+#448 Training Accuracy: 100.00% Testing Accuracy: 99.45% Training Time: 32.10s Testing Time: 6.09s
+#449 Training Accuracy: 100.00% Testing Accuracy: 99.47% Training Time: 32.06s Testing Time: 6.07s
+#450 Training Accuracy: 100.00% Testing Accuracy: 99.45% Training Time: 31.96s Testing Time: 6.08s
+...
+```
+
+## Paper
+
+_A Tsetlin Machine for Logical Learning and Reasoning With AND-OR Hierarchies_. Ole-Christoffer Granmo, et al., 2026. (Forthcoming)
+
+## Licence
+
+MIT License
+
+Copyright (c) 2026 Ole-Christoffer Granmo and the University of Agder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{PyHierarchicalTsetlinMachineCUDA-0.2.2 → PyHierarchicalTsetlinMachineCUDA-0.2.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import *
 
 setup(
    name='PyHierarchicalTsetlinMachineCUDA',
-   version='0.2.2',
+   version='0.2.5',
    author='Ole-Christoffer Granmo',
    author_email='ole.granmo@uia.no',
    url='https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/',
@@ -16,8 +16,9 @@ setup(
 		'pycuda',
 		'scipy',
 		'scikit-learn',
+		'networkx',
 	],
 	extras_require={
-		'examples': ['tensorflow'],
+		'examples': ['tensorflow', 'matplotlib', 'pygraphviz'],
 	}
 )

PyHierarchicalTsetlinMachineCUDA-0.2.2/README.md

@@ -1,107 +0,0 @@
-# Hierarchical Tsetlin Machine in CUDA
-Implements the [Hierarchical Tsetlin Machine](https://github.com/cair/HierarchicalTsetlinMachine) in CUDA.
-
-<p align="center">
-  <img width="70%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/main/figures/Clause_Plot_Mayur_Shende.png">
-</p>
-
-## Installation
-
-```bash
-pip install pyhierarchicaltsetlinmachinecuda
-```
-or
-```bash
-git clone git@github.com:cair/PyHierarchicalTsetlinMachineCUDA.git
-cd PyHierarchicalTsetlinMachineCUDA
-python ./setup.py sdist
-pip install dist/pyhierarchicaltsetlinmachinecuda-0.2.1.tar.gz 
-```
-
-## Examples
-
-### Noisy Parity Demo
-
-#### Code: NoisyParityDemo.py
-
-```python
-from PyHierarchicalTsetlinMachineCUDA.tm import TsetlinMachine
-import numpy as np
-from time import time
-import PyHierarchicalTsetlinMachineCUDA.tm as tm
-
-train_data = np.loadtxt("./examples/NoisyParityTrainingData.txt").astype(np.uint32)
-X_train = train_data[:,0:-1]
-Y_train = train_data[:,-1]
-
-test_data = np.loadtxt("./examples/NoisyParityTestingData.txt").astype(np.uint32)
-X_test = test_data[:,0:-1]
-Y_test = test_data[:,-1]
-
-tm = TsetlinMachine(32, 3000, 30.1,
-	number_of_state_bits=8,
-	boost_true_positive_feedback=0,
-	hierarchy_structure=(
-		(tm.AND_GROUP, 3),
-		(tm.OR_ALTERNATIVES, 10),
-		(tm.AND_GROUP, 2),
-		(tm.OR_ALTERNATIVES, 2),
-		(tm.AND_GROUP, 2)
-	)
-)
-
-print("\nAccuracy over 500 epochs:\n")
-for i in range(500):
-	start_training = time()
-	tm.fit(X_train, Y_train, epochs=10, incremental=True)
-	stop_training = time()
-
-	start_testing = time()
-	result = 100*(tm.predict(X_test) == Y_test).mean()
-	stop_testing = time()
-
-	print("#%d Accuracy: %.2f%% Training: %.2fs Testing: %.2fs" % (i+1, result, stop_training-start_training, stop_testing-start_testing))
-```
-
-#### Output
-
-```bash
-python ./examples/NoisyParityData.py
-python ./examples/NoisyParityDemo.py
-
-#1 Accuracy: 58.54% Training: 22.36s Testing: 1.39s
-#2 Accuracy: 61.03% Training: 22.40s Testing: 1.39s
-#3 Accuracy: 72.43% Training: 22.42s Testing: 1.39s
-...
-#88 Accuracy: 99.87% Training: 24.39s Testing: 1.51s
-#89 Accuracy: 99.38% Training: 24.40s Testing: 1.52s
-#90 Accuracy: 99.94% Training: 24.39s Testing: 1.52s
-```
-
-### Paper
-
-_A Tsetlin Machine for Logical Learning and Reasoning With AND-OR Hierarchies_. Ole-Christoffer Granmo, et al., 2026. (Forthcoming)
-
-## Licence
-
-MIT License
-
-Copyright (c) 2026 Ole-Christoffer Granmo and the University of Agder
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.