pyhierarchicaltsetlinmachinecuda 0.2.0__tar.gz

pyhierarchicaltsetlinmachinecuda-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+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.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pyhierarchicaltsetlinmachinecuda
+Version: 0.2.0
+Summary: Hierarchical Tsetlin Machine Architecture.
+Home-page: https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/
+Author: Ole-Christoffer Granmo
+Author-email: ole.granmo@uia.no
+License: MIT
+Keywords: pattern-recognition cuda machine-learning interpretable-machine-learning rule-based-machine-learning propositional-logic tsetlin-machine regression convolution classification multi-layer
+License-File: LICENSE
+
+Hierarchical Tsetlin Machine Architecture.

pyhierarchicaltsetlinmachinecuda-0.2.0/PyHierarchicalTsetlinMachineCUDA/__init__.py

@@ -0,0 +1 @@
+

pyhierarchicaltsetlinmachinecuda-0.2.0/PyHierarchicalTsetlinMachineCUDA/graph.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2024 Ole-Christoffer Granmo
+
+# 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.
+
+import numpy as np
+from scipy.sparse import coo_matrix
+
+class Graph():
+	def __init__(self):
+		self.node_name_id = {}
+		self.node_id_name = {}
+		self.node_edges = {}
+		self.node_features = {}
+		self.edge_counter = 0
+		self.feature_counter = 0
+
+	def add_node(self, node_name):
+		self.node_name_id[node_name] = len(self.node_name_id)
+		self.node_id_name[self.node_name_id[node_name]] = node_name
+		self.node_features[node_name] = []
+		self.node_edges[node_name] = []
+
+	def add_edge(self, node_name_1, node_name_2, edge_type=0):
+		self.node_edges[node_name_1].append((node_name_2, edge_type))
+		self.edge_counter += 1
+
+	def add_feature(self, node_name, symbols):
+		if type(symbols) == tuple:
+			symbols = " ".join(symbols)
+		self.node_features[node_name].append(symbols)
+		self.feature_counter += 1
+
+class Graphs():
+	def __init__(self):
+		self.edge_type_id = {}
+		self.graphs = []
+		self.encoded = False
+
+	def add(self, graph):
+		self.graphs.append(graph)
+
+	def encode(self, hypervectors = {}, hypervector_size=1024, hypervector_bits=3):
+		self.hypervectors = hypervectors
+
+		self.hypervector_size = hypervector_size
+		self.hypervector_bits = hypervector_bits
+
+		global_feature_counter = 0
+		global_edge_counter = 0
+		for graph in self.graphs:
+			global_feature_counter += graph.feature_counter *  self.hypervector_bits
+			global_edge_counter += len(graph.node_name_id) + graph.edge_counter*2
+
+		indexes = np.arange(self.hypervector_size, dtype=np.uint32)
+
+		feature_row = np.empty(global_feature_counter, dtype=np.uint32)
+		feature_col = np.empty(global_feature_counter, dtype=np.uint32)
+		feature_data = np.empty(global_feature_counter, dtype=np.uint32)
+
+		edge_row = np.empty(global_edge_counter, dtype=np.uint32)
+		edge_col = np.empty(global_edge_counter, dtype=np.uint32)
+		edge_data = np.empty(global_edge_counter, dtype=np.uint32)
+
+		self.node_count = np.empty(len(self.graphs), dtype=np.uint32)
+
+		feature_position = 0
+		edge_position = 0
+		for i in range(len(self.graphs)):
+			graph = self.graphs[i]
+			self.node_count[i] = len(graph.node_name_id)
+			local_edge_position = 0
+			for j in range(len(graph.node_name_id)):
+				node_name = graph.node_id_name[j]
+
+				for symbols in graph.node_features[node_name]:
+					if symbols not in self.hypervectors:
+						self.hypervectors[symbols] = np.random.choice(indexes, size=(self.hypervector_bits), replace=False)
+				
+					for k in range(self.hypervector_bits):
+						feature_row[feature_position] = i
+						feature_col[feature_position] = self.hypervectors[symbols][k] + j*self.hypervector_size
+						feature_data[feature_position] = 1
+						feature_position += 1
+
+				edge_row[edge_position] = i
+				edge_col[edge_position] = local_edge_position
+				edge_data[edge_position] = len(graph.node_edges[node_name])
+				edge_position += 1
+				local_edge_position += 1
+				for edge in graph.node_edges[graph.node_id_name[j]]:
+					edge_row[edge_position] = i
+					edge_col[edge_position] = local_edge_position
+					edge_data[edge_position] = graph.node_name_id[edge[0]]
+					edge_position += 1
+					local_edge_position += 1
+
+					edge_row[edge_position] = i
+					edge_col[edge_position] = local_edge_position
+
+					if edge[1] not in self.edge_type_id:
+						self.edge_type_id[edge[1]] = len(self.edge_type_id)
+					edge_data[edge_position] = self.edge_type_id[edge[1]]
+					edge_position += 1
+					local_edge_position += 1
+
+		self.X = coo_matrix((feature_data, (feature_row, feature_col))).tocsr()
+		self.X.sum_duplicates()
+
+		self.edges = coo_matrix((edge_data, (edge_row, edge_col))).tocsr()
+
+		self.max_node_count = self.node_count.max()
+
+		self.signature = np.concatenate((self.X.indptr, self.X.indices, self.edges.indptr, self.edges.indices, self.edges.data))
+
+		self.encoded = True
+
+		return

pyhierarchicaltsetlinmachinecuda-0.2.0/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -0,0 +1,510 @@
+# 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.
+
+# This code implements the Convolutional Tsetlin Machine from paper arXiv:1905.09688
+# https://arxiv.org/abs/1905.09688
+
+code_header = """
+	#include <curand_kernel.h>
+	
+	#define INT_SIZE 32ULL
+
+	#define LITERAL_LEAVES (LITERAL_CHUNKS / TA_CHUNKS_PER_LEAF)
+
+	#if (LITERALS_PER_LEAF % 32 != 0)
+	#define FILTER_HIERARCHICAL (~(0xffffffff << (LITERALS_PER_LEAF % INT_SIZE)))
+	#else
+	#define FILTER_HIERARCHICAL 0xffffffff
+	#endif
+
+	#define VANILLA_TM 0
+
+	#define WEIGHTED_TM 1
+
+	#define COALESCED_TM 2
+"""
+
+code_update = """
+	extern "C"
+    {
+    	// Increment the states of each of those 32 Tsetlin Automata flagged in the active bit vector.
+		__device__ inline void inc(unsigned int *ta_state, int chunk, unsigned int active)
+		{
+			unsigned int carry, carry_next;
+			int id = chunk*STATE_BITS;
+			carry = active;
+			for (int b = 0; b < STATE_BITS; ++b) {
+				if (carry == 0)
+					break;
+
+				carry_next = ta_state[id + b] & carry; // Sets carry bits (overflow) passing on to next bit
+				ta_state[id + b] = ta_state[id + b] ^ carry; // Performs increments with XOR
+				carry = carry_next;
+			}
+
+			if (carry > 0) {
+				for (int b = 0; b < STATE_BITS; ++b) {
+					ta_state[id + b] |= carry;
+				}
+			}   
+		}
+
+		// Decrement the states of each of those 32 Tsetlin Automata flagged in the active bit vector.
+		__device__ inline void dec(unsigned int *ta_state, int chunk, unsigned int active)
+		{
+			unsigned int carry, carry_next;
+			int id = chunk*STATE_BITS;
+			carry = active;
+			for (int b = 0; b < STATE_BITS; ++b) {
+				if (carry == 0)
+					break;
+				carry_next = (~ta_state[id + b]) & carry; // Sets carry bits (overflow) passing on to next bit
+				ta_state[id + b] = ta_state[id + b] ^ carry; // Performs increments with XOR
+				carry = carry_next;
+			}
+
+			if (carry > 0) {
+				for (int b = 0; b < STATE_BITS; ++b) {
+					ta_state[id + b] &= ~carry;
+				}
+			} 
+		}
+
+		__device__ inline void update_clause_weight(curandState *localState, int tm_type, int number_of_outputs, int *clause_weight, int clause_output, int y, int class_sum)
+		{
+			int target = 1 - 2*(class_sum > y);
+			
+			if (target == -1 && curand_uniform(localState) > 1.0*Q/max(1, number_of_outputs-1)) {
+				return;
+			}
+
+			int sign = (*clause_weight >= 0) - (*clause_weight < 0);
+		
+			int absolute_prediction_error = abs(y - class_sum);
+			if (curand_uniform(localState) <= 1.0*absolute_prediction_error/(2*THRESHOLD)) {
+				if (target*sign > 0) {
+					if (clause_output && abs(*clause_weight) < INT_MAX) {
+						(*clause_weight) += sign;
+					}
+				} else if (target*sign < 0 && clause_output) {
+					// Type II Feedback
+
+					if (*clause_weight < -1 || *clause_weight > 1 || tm_type == COALESCED_TM) {
+						(*clause_weight) -= sign;
+					}
+
+					#if NEGATIVE_CLAUSES == 0
+						if (*clause_weight < 1) {
+							*clause_weight = 1;
+						}
+					#endif
+				}
+			}
+		}
+
+		__device__ inline void update_component_hierarchy(curandState *localState, int number_of_outputs, int *clause_weight, unsigned int *ta_state, int component_output, int *X, int y, int class_sum)
+		{
+			int target = 1 - 2*(class_sum > y);
+			
+			if (target == -1 && curand_uniform(localState) > 1.0*Q/max(1, number_of_outputs-1)) {
+				return;
+			}
+			
+
+			int sign = (*clause_weight >= 0) - (*clause_weight < 0);
+		
+			int absolute_prediction_error = abs(y - class_sum);
+			if (curand_uniform(localState) <= 1.0*absolute_prediction_error/(2*THRESHOLD)) {
+				if (target*sign > 0) {
+					// Type I Feedback
+					for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF; ++ta_chunk) {
+						// Generate random bit values
+						unsigned int la_feedback = 0;
+						for (int b = 0; b < INT_SIZE; ++b) {
+							if (curand_uniform(localState) <= 1.0/S) {
+								la_feedback |= (1 << b);
+							}
+						}
+
+						if (component_output) {
+							#if BOOST_TRUE_POSITIVE_FEEDBACK == 1
+								inc(ta_state, ta_chunk, X[ta_chunk]);
+							#else
+								inc(ta_state, ta_chunk, X[ta_chunk] & (~la_feedback));
+							#endif
+
+							dec(ta_state, ta_chunk, (~X[ta_chunk]) & la_feedback);
+						} else {
+							dec(ta_state, ta_chunk, la_feedback);
+						}
+					}
+				} else if (target*sign < 0 && component_output) {
+					// Type II Feedback
+
+					for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF; ++ta_chunk) {
+						inc(ta_state, ta_chunk, (~X[ta_chunk]) & (~ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1]));
+					}
+				}
+			}
+		}
+
+		// Evaluate example
+		__global__ void evaluate_leaves(unsigned int *global_ta_state, int *component_weights, int *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_alternatives, int *X, int example)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			int *Xi = &X[(unsigned long long)example*LITERAL_CHUNKS];
+
+			// Evaluate each clause component (leaf) in separate threads
+			for (int clause_component = index; clause_component < CLAUSES*COMPONENTS; clause_component += stride) {
+				int clause = clause_component / COMPONENTS;
+				int component = clause_component % COMPONENTS;
+
+				// Get state of current clause component
+				unsigned int *ta_state = &global_ta_state[clause_component*TA_CHUNKS_PER_LEAF*STATE_BITS];
+
+				int component_remainder = component;
+				int ta_chunk_base = 0;
+				int size = 1;
+				for (int d = 0; d < depth-1; ++d) {
+					int depth_d_node_index = component_remainder % hierarchy_structure_factors[d];
+					component_remainder = component_remainder / hierarchy_structure_factors[d];
+
+					if (hierarchy_structure_alternatives[d] == 0) {
+						ta_chunk_base += size * depth_d_node_index * TA_CHUNKS_PER_LEAF;
+						size *= hierarchy_structure_factors[d];
+					}
+
+					if (clause == -1 && d == depth-2) {
+						printf("%d: %d (%d) (%d = %d) %d\\n", d, component, depth_d_node_index, ta_chunk_base, (component % (LITERAL_CHUNKS / TA_CHUNKS_PER_LEAF))*TA_CHUNKS_PER_LEAF, component_remainder);
+					}
+				}
+
+				// Evaluate clause component
+				int component_output = 1;
+				for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF-1; ++ta_chunk) {
+					// Compare the TA state of the component (leaf) against the corresponding part of the feature vector
+					if ((ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1] & Xi[ta_chunk_base + ta_chunk]) != ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1]) {
+						component_output = 0;
+						break;
+					}
+				}
+
+				if ((ta_state[(TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS - 1] & Xi[ta_chunk_base + TA_CHUNKS_PER_LEAF-1] & FILTER_HIERARCHICAL) != (ta_state[(TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS - 1] & FILTER_HIERARCHICAL)) {
+					component_output = 0;
+				}
+
+				global_component_output[clause_component] = component_output;
+			}
+		}
+
+		__global__ void evaluate_or_groups(int *child_input, int *or_group_node_output, int number_of_or_group_nodes, int number_of_or_group_addends)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// Add up the votes of each OR node child
+			for (int or_group_node = index; or_group_node < CLAUSES*number_of_or_group_nodes; or_group_node += stride) {
+				// Add OR addends
+				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
+					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; 
+					//}
+				}
+
+				// Store or group vote sum as node output
+				or_group_node_output[or_group_node] = or_group_vote_sum;
+			}
+		}
+
+		__global__ void evaluate_and_groups(int *child_input, int *and_group_node_output, int number_of_and_group_nodes, int number_of_and_group_factors)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// Multiply the votes from the children of each AND node
+			for (int and_group_node = index; and_group_node < CLAUSES*number_of_and_group_nodes; and_group_node += stride) {
+				// Multiply and factors
+				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
+					and_group_vote_product *= child_input[and_group_node*number_of_and_group_factors + and_factor];
+				}
+
+				// Store and group product as node output
+				and_group_node_output[and_group_node] = and_group_vote_product;
+			}
+		}
+
+		__global__ void propagate_and_group_false_truth_values(int *child_input, int *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// If a group node is false, all children are made false.
+			for (int group_node = index; group_node < CLAUSES*number_of_group_nodes; group_node += stride) {
+				if (group_node_output[group_node] == 0) {
+					for (int and_factor = 0; and_factor < number_of_group_node_children; ++and_factor) {
+						if (child_input[group_node*number_of_group_node_children + and_factor] > 0) {
+							child_input[group_node*number_of_group_node_children + and_factor] = 0;	
+						}
+					}
+				}
+			}
+		}
+
+		__global__ void evaluate_or_alternatives(int *child_input, int *or_alternatives_node_output, int number_of_or_alternatives_nodes, int number_of_or_alternatives)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// Add up the votes from the children of each OR node
+			for (int or_alternatives_node = index; or_alternatives_node < CLAUSES*number_of_or_alternatives_nodes; or_alternatives_node += stride) {
+				// Sum up votes from each or alternative
+				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
+					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;
+					//}
+				}
+
+				// Store vote sum as node output
+				or_alternatives_node_output[or_alternatives_node] = or_alternatives_vote_sum;
+			}
+		}
+
+		__global__ void evaluate_final(int number_of_outputs, int *child_input, int *clause_weights, int *class_sum)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// Add up the votes from each clause
+			for (int clause = index; clause < CLAUSES; clause += stride) {
+				if (child_input[clause]) {
+					for (int class_id = 0; class_id < number_of_outputs; ++class_id) {
+						int clause_weight = clause_weights[class_id*CLAUSES + clause];
+						atomicAdd(&class_sum[class_id], clause_weight * child_input[clause]);					
+					}
+				}
+			}
+		}
+
+		// Update state of Tsetlin Automata team
+		__global__ void update_hierarchy(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, int *component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_alternatives, int *class_sum, int *X, int *y, int example)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			/* Copy state to local memory for efficiency */  
+			curandState localState = state[index];
+			
+			int *Xi = &X[(unsigned long long)example*LITERAL_CHUNKS];
+
+			// Calculate clause output first
+			for (int clause_component = index; clause_component < CLAUSES*COMPONENTS; clause_component += stride) {
+				int clause = clause_component / COMPONENTS;
+				int component = clause_component % COMPONENTS;
+
+				// Get state of current clause component
+				unsigned int *ta_state = &global_ta_state[clause_component*TA_CHUNKS_PER_LEAF*STATE_BITS];
+
+				int component_remainder = component;
+				int ta_chunk_base = 0;
+				int size = 1;
+				for (int d = 0; d < depth-1; ++d) {
+					int depth_d_node_index = component_remainder % hierarchy_structure_factors[d];
+					component_remainder = component_remainder / hierarchy_structure_factors[d];
+
+					if (hierarchy_structure_alternatives[d] == 0) {
+						ta_chunk_base += size * depth_d_node_index * TA_CHUNKS_PER_LEAF;
+						size *= hierarchy_structure_factors[d];
+					}
+				}
+
+				for (unsigned long long class_id = 0; class_id < number_of_outputs; ++class_id) {
+					int local_class_sum = class_sum[class_id];
+					if (local_class_sum > THRESHOLD) {
+						local_class_sum = THRESHOLD;
+					} else if (local_class_sum < -THRESHOLD) {
+						local_class_sum = -THRESHOLD;
+					}
+					update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component], &Xi[ta_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
+				}
+			}
+		
+			state[index] = localState;
+		}
+
+		// Update state of Tsetlin Automata team
+		__global__ void update_weights(curandState *state, int tm_type, int number_of_outputs, int *clause_weights, int *clause_output, int *class_sum, int *y, int example)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			/* Copy state to local memory for efficiency */  
+			curandState localState = state[index];
+
+			for (unsigned long long clause = index; clause < CLAUSES; clause += stride) {
+				for (unsigned long long class_id = 0; class_id < number_of_outputs; ++class_id) {
+					int local_class_sum = class_sum[class_id];
+					if (local_class_sum > THRESHOLD) {
+						local_class_sum = THRESHOLD;
+					} else if (local_class_sum < -THRESHOLD) {
+						local_class_sum = -THRESHOLD;
+					}
+					update_clause_weight(&localState, tm_type, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], clause_output[clause], y[example*number_of_outputs + class_id], local_class_sum);
+				}
+			}
+		
+			state[index] = localState;
+		}
+    }
+"""
+
+code_prepare = """
+	extern "C"
+    {
+		__global__ void prepare_weights(curandState *state, int tm_type, int number_of_outputs, int *clause_weights, int *class_sum)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			curandState localState = state[index];
+
+			for (unsigned long long clause = index; clause < CLAUSES; clause += stride) {
+				for (unsigned long long class_id = 0; class_id < number_of_outputs; ++class_id) {
+					#if NEGATIVE_CLAUSES == 1
+						if (tm_type == COALESCED_TM) {
+							clause_weights[class_id*CLAUSES + clause] = 1 - 2 * (curand(&localState) % 2);
+						} else {
+							if (class_id*CLAUSES <= clause && clause < (class_id+1)*CLAUSES) {
+								clause_weights[class_id*CLAUSES + clause] = 1 - 2 * (clause % 2);
+							} else {
+								clause_weights[class_id*CLAUSES + clause] = 0;
+							}
+						}
+					#else
+						clause_weights[class_id*CLAUSES + clause] = 1;
+					#endif
+				}
+			}
+
+			state[index] = localState;
+		}
+
+		__global__ void prepare_hierarchy(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, int *class_sum)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			curandState localState = state[index];
+
+			// Evaluate each clause component (leaf) in separate threads
+			for (int clause_component = index; clause_component < CLAUSES*COMPONENTS; clause_component += stride) {
+				// Get state of current clause component
+				unsigned int *ta_state = &global_ta_state[clause_component*TA_CHUNKS_PER_LEAF*STATE_BITS];
+				for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF; ++ta_chunk) {
+					for (int b = 0; b < STATE_BITS-1; ++b) {
+						ta_state[ta_chunk*STATE_BITS + b] = ~0;
+					}
+					ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1] = 0;
+				}
+			}
+
+			for (unsigned long long clause = index; clause < CLAUSES; clause += stride) {
+				for (unsigned long long class_id = 0; class_id < number_of_outputs; ++class_id) {
+					#if NEGATIVE_CLAUSES == 1
+						clause_weights[class_id*CLAUSES + clause] = 1 - 2 * (curand(&localState) % 2);
+					#else
+						clause_weights[class_id*CLAUSES + clause] = 1;
+					#endif
+				}				
+			}
+
+			state[index] = localState;
+		}
+	}
+"""
+
+code_encode = """
+	#include <curand_kernel.h>
+
+	extern "C"
+    {
+		__global__ void prepare_encode_hierarchy(unsigned int *X, unsigned int *encoded_X, int number_of_literal_chunks, int number_of_examples)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			for (unsigned long long i = index; i < number_of_examples * number_of_literal_chunks; i += stride) {
+				encoded_X[i] = 0;
+			}
+		}
+
+		__global__ void encode_hierarchy(unsigned int *X, unsigned int *encoded_X, int number_of_features, int number_of_literal_chunks, int number_of_leaves, int number_of_features_per_leaf, int number_of_literal_chunks_per_leaf, int append_negated, int number_of_examples)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			unsigned int *Xi;
+			unsigned int *encoded_Xi;
+
+			for (unsigned long long i = index; i < number_of_examples; i += stride) {
+				Xi = &X[i*number_of_features];
+				encoded_Xi = &encoded_X[i*number_of_literal_chunks];
+
+				for (int j = 0; j < number_of_features / number_of_features_per_leaf; ++j) {
+					for (int k = 0; k < number_of_features_per_leaf; ++k) {
+						if (Xi[j*number_of_features_per_leaf + k] == 1) {
+							int leaf_chunk_nr = k / 32;
+							int leaf_chunk_pos = k % 32;
+							encoded_Xi[j*number_of_literal_chunks_per_leaf + leaf_chunk_nr] |= (1 << leaf_chunk_pos);
+						} else if (append_negated) {
+							int leaf_chunk_nr = (k + number_of_features_per_leaf) / 32;
+							int leaf_chunk_pos = (k + number_of_features_per_leaf) % 32;
+							encoded_Xi[j*number_of_literal_chunks_per_leaf + leaf_chunk_nr] |= (1 << leaf_chunk_pos);
+						}
+					}
+				}
+			} 
+		}
+	}
+"""
+
+code_transform = """
+	extern "C"
+    {
+		// Transform examples
+		__global__ void transform(unsigned int *global_ta_state, int *X, int *transformed_X)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			// To be updated
+		}
+	}
+"""

pyhierarchicaltsetlinmachinecuda-0.2.0/PyHierarchicalTsetlinMachineCUDA/tm.py

@@ -0,0 +1,502 @@
+# 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.
+
+# This code implements the Convolutional Tsetlin Machine from paper arXiv:1905.09688
+# https://arxiv.org/abs/1905.09688
+
+import numpy as np
+
+import PyHierarchicalTsetlinMachineCUDA.kernels as kernels
+
+import pycuda.curandom as curandom
+import pycuda.driver as cuda
+import pycuda.autoinit
+from pycuda.compiler import SourceModule
+
+from time import time
+
+OR_GROUP = "OR a group of children"
+OR_ALTERNATIVES = "Create multiple OR alternatives for a sub hierarchy"
+AND_GROUP = "AND a group of children"
+
+VANILLA_TM = 0
+WEIGHTED_TM = 1
+COALESCED_TM = 2
+
+g = curandom.XORWOWRandomNumberGenerator() 
+
+class CommonTsetlinMachine():
+
+	def __init__(self, number_of_clauses, T, s, tm_type=VANILLA_TM, 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)):
+		self.number_of_clauses = number_of_clauses
+		self.number_of_state_bits = number_of_state_bits
+		self.T = int(T)
+		self.s = s
+		self.tm_type = tm_type
+		self.q = q
+		self.hierarchy_structure = hierarchy_structure
+		self.depth = len(hierarchy_structure)
+
+		self.boost_true_positive_feedback = boost_true_positive_feedback
+		self.append_negated = append_negated
+		self.grid = grid
+		self.block = block
+
+		# Calculates the number of nodes at each level of the hierarchy
+		self.hierarchy_size = [0] * (self.depth + 1)
+		self.hierarchy_size[self.depth] = 1
+		for d in range(self.depth - 1):
+			self.hierarchy_size[self.depth - d - 1] = self.hierarchy_structure[self.depth - d - 1][1] * self.hierarchy_size[self.depth - d]
+
+		# Represents hierarchy structure for transfer to GPU
+		self.hierarchy_structure_factors = [0] * (self.depth - 1)
+		self.hierarchy_structure_alternatives = [0] * (self.depth - 1)
+		for d in range(1, self.depth):
+			self.hierarchy_structure_factors[d-1] = self.hierarchy_structure[d][1]
+			if self.hierarchy_structure[d][0] == OR_ALTERNATIVES:
+				self.hierarchy_structure_alternatives[d-1] = 1
+
+		# Calculates total number of features spanned by the hierarchy
+		self.number_of_features_hierarchy = 1
+		for d in range(self.depth - 1, -1, -1):
+			if (self.hierarchy_structure[d][0] == OR_GROUP or self.hierarchy_structure[d][0] == AND_GROUP):
+				self.number_of_features_hierarchy *= self.hierarchy_structure[d][1]
+
+		# Calculates literal chunks per leaf
+		self.number_of_features_per_leaf = self.hierarchy_structure[0][1]
+		if self.append_negated:
+			self.number_of_literals = self.number_of_features_hierarchy * 2
+			self.number_of_literals_per_leaf = self.number_of_features_per_leaf * 2
+			self.number_of_literal_chunks_per_leaf = int((self.number_of_literals_per_leaf - 1) / 32 + 1)
+		else:
+			self.number_of_literals = self.number_of_features_hierarchy
+			self.number_of_literals_per_leaf = self.number_of_features_per_leaf
+			self.number_of_literal_chunks_per_leaf = int((self.number_of_literals_per_leaf - 1) / 32 + 1)
+
+		# Calculates the number of literal chunks for the full hierarchy
+		self.hierarchy_size[0] = self.number_of_literal_chunks_per_leaf * self.hierarchy_size[1]
+
+		# Calculates number of literal chunks overall for the feature vector (ignores OR alternatives)
+		self.number_of_literal_chunks = self.number_of_literal_chunks_per_leaf
+		for d in range(self.depth - 1, 0, -1):
+			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.cuda_modules()
+
+		self.first = True
+
+	def cuda_modules(self):
+		parameters = """
+	#define CLAUSES %d
+	#define DEPTH %d
+	#define COMPONENTS %d
+	#define LITERALS_PER_LEAF %d
+	#define TA_CHUNKS_PER_LEAF %d
+	#define LITERAL_CHUNKS %d
+	#define STATE_BITS %d
+	#define BOOST_TRUE_POSITIVE_FEEDBACK %d
+	#define S %f
+	#define THRESHOLD %d
+	#define Q %f
+
+	#define NEGATIVE_CLAUSES %d
+		""" % (self.number_of_clauses, self.depth, self.hierarchy_size[1], self.number_of_literals_per_leaf, self.number_of_literal_chunks_per_leaf, self.number_of_literal_chunks, self.number_of_state_bits, self.boost_true_positive_feedback, self.s, self.T, self.q, self.negative_clauses)
+		
+		mod_prepare = SourceModule(parameters + kernels.code_header + kernels.code_prepare, no_extern_c=True)
+		self.prepare_weights = mod_prepare.get_function("prepare_weights")
+		self.prepare_hierarchy = mod_prepare.get_function("prepare_hierarchy")
+
+		mod_update = SourceModule(parameters + kernels.code_header + kernels.code_update, no_extern_c=True)		
+		self.update_hierarchy = mod_update.get_function("update_hierarchy")
+		self.update_hierarchy.prepare("PiPPPiPPPPPi")
+
+		self.update_weights = mod_update.get_function("update_weights")
+		self.update_weights.prepare("PiiPPPPi")
+
+		self.evaluate_leaves = mod_update.get_function("evaluate_leaves")
+		self.evaluate_leaves.prepare("PPPiPPPi")
+
+		self.evaluate_final = mod_update.get_function("evaluate_final")
+		self.evaluate_final.prepare("iPPP")
+
+		self.evaluate_and_groups = mod_update.get_function("evaluate_and_groups")
+		self.evaluate_and_groups.prepare("PPii")
+
+		self.propagate_and_group_false_truth_values = mod_update.get_function("propagate_and_group_false_truth_values")
+		self.propagate_and_group_false_truth_values.prepare("PPii")
+
+		self.evaluate_or_groups = mod_update.get_function("evaluate_or_groups")
+		self.evaluate_or_groups.prepare("PPii")
+
+		self.evaluate_or_alternatives = mod_update.get_function("evaluate_or_alternatives")
+		self.evaluate_or_alternatives.prepare("PPii")
+
+		# CUDA modules for encoding input data
+		mod_encode = SourceModule(kernels.code_encode, no_extern_c=True)
+		self.prepare_encode_hierarchy = mod_encode.get_function("prepare_encode_hierarchy")
+		self.encode_hierarchy = mod_encode.get_function("encode_hierarchy")
+
+
+	def encode_X(self, X, encoded_X_hierarchy_gpu):
+		number_of_examples = X.shape[0]
+
+		# Allocates GPU memory for input data
+		Xm = np.ascontiguousarray(X.flatten()).astype(np.uint32)
+		X_gpu = cuda.mem_alloc(Xm.nbytes)
+		cuda.memcpy_htod(X_gpu, Xm)
+
+		# Prepares for leaf encoding of the input data
+		self.prepare_encode_hierarchy(X_gpu, encoded_X_hierarchy_gpu, np.int32(self.number_of_literal_chunks), np.int32(number_of_examples), grid=self.grid, block=self.block)
+		cuda.Context.synchronize()	
+		
+		# Encodes the input data split across the leaves
+		self.encode_hierarchy(X_gpu, encoded_X_hierarchy_gpu, np.int32(self.number_of_features_hierarchy), np.int32(self.number_of_literal_chunks), np.int32(self.hierarchy_size[1]), np.int32(self.number_of_features_per_leaf), np.int32(self.number_of_literal_chunks_per_leaf), np.int32(self.append_negated), np.int32(number_of_examples), grid=self.grid, block=self.block)
+		cuda.Context.synchronize()
+
+	def allocate_gpu_memory(self):
+		# 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))
+
+		# GPU memory for storing hierarchy structure
+		self.hierarchy_structure_factors_gpu = cuda.mem_alloc((self.depth-1)*4)
+		cuda.memcpy_htod(self.hierarchy_structure_factors_gpu, np.array(self.hierarchy_structure_factors, dtype=np.int32))
+
+		# GPU memory for storing hierarchy structure
+		self.hierarchy_structure_alternatives_gpu = cuda.mem_alloc((self.depth-1)*4)
+		cuda.memcpy_htod(self.hierarchy_structure_alternatives_gpu, np.array(self.hierarchy_structure_alternatives, dtype=np.int32))
+
+		# GPU memory for storing Tsetlin Automata states
+		self.ta_state_hierarchy_gpu = cuda.mem_alloc(self.number_of_clauses*self.hierarchy_size[0]*self.number_of_state_bits*4)
+		self.clause_weights_gpu = cuda.mem_alloc(self.number_of_outputs*self.number_of_clauses*4)
+		self.component_weights_gpu = cuda.mem_alloc(self.number_of_clauses*self.hierarchy_size[1]*4) # Only positive weights...
+		self.class_sum_gpu = cuda.mem_alloc(self.number_of_outputs*4)
+
+	def ta_action(self, clause, leaf, ta):
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.hierarchy_size[1]*self.number_of_literal_chunks_per_leaf*self.number_of_state_bits, dtype=np.uint32)
+		cuda.memcpy_dtoh(ta_state_hierarchy, self.ta_state_hierarchy_gpu)
+		ta_state_hierarchy = self.ta_state_hierarchy.reshape((self.number_of_clauses, self.hierarchy_size[1], self.number_of_literal_chunks_per_leaf, self.number_of_state_bits))
+
+		return (ta_state[clause, leaf, ta // 32, self.number_of_state_bits-1] & (1 << (ta % 32))) > 0
+
+	def get_state(self):
+		# To be updated
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.hierarchy_size[1]*self.number_of_literal_chunks_per_leaf*self.number_of_state_bits, dtype=np.uint32)
+		cuda.memcpy_dtoh(self.ta_state_hierarchy, self.ta_state_hierarchy_gpu)
+		clause_weights = np.empty(self.number_of_outputs*self.number_of_clauses).astype(np.int32)
+		cuda.memcpy_dtoh(self.clause_weights, self.clause_weights_gpu)
+		return((self.ta_state_hierarchy, self.clause_weights, self.number_of_outputs, self.number_of_clauses, self.hierarchy_structure, self.boost_true_positive_feedback, self.number_of_state_bits, self.append_negated, self.min_y, self.max_y))
+
+	def set_state(self, state):
+		# To be updated
+		self.number_of_outputs = state[2]
+		self.number_of_clauses = state[3]
+		self.hierarchy_structure = state[4]
+		self.boost_true_positive_feedback = state[5]
+		self.number_of_state_bits = state[6]
+		self.append_negated = state[7]
+		self.min_y = state[8]
+		self.max_y = state[9]
+		
+		self.ta_state_hierarchy_gpu = cuda.mem_alloc(self.number_of_clauses*self.hierarchy_size[0]*self.number_of_state_bits*4)
+		self.clause_weights_gpu = cuda.mem_alloc(self.number_of_outputs*self.number_of_clauses*4)
+		cuda.memcpy_htod(self.ta_state_hierarchy_gpu, state[0])
+		cuda.memcpy_htod(self.clause_weights_gpu, state[1])
+
+	# Transform input data for processing at next layer
+	def transform(self, X):
+		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)
+		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)
+		cuda.Context.synchronize()
+
+	def evaluate_hierarchy(self, encoded_X_hierarchy, e):
+		# Initializes class sums to zero
+		class_sum = np.ascontiguousarray(np.zeros(self.number_of_outputs)).astype(np.int32)
+		cuda.memcpy_htod(self.class_sum_gpu, class_sum)
+
+		# Evaluates all the hierarchy leaves in parallel
+		self.evaluate_leaves.prepared_call(
+			self.grid,
+			self.block,
+			self.ta_state_hierarchy_gpu,
+			self.component_weights_gpu,
+			self.hierarchy_votes[0],
+			self.depth,
+			self.hierarchy_structure_factors_gpu,
+			self.hierarchy_structure_alternatives_gpu,
+			encoded_X_hierarchy,
+			np.int32(e)
+		)
+		cuda.Context.synchronize()
+
+		# Propagates votes bottom-up in the hierarchy, starting from the clause components (leaves)
+		for d in range(1, self.depth):
+			if (self.hierarchy_structure[d][0] == AND_GROUP):
+				self.evaluate_and_groups.prepared_call(
+					self.grid,
+					self.block,
+					self.hierarchy_votes[d-1],
+					self.hierarchy_votes[d],
+					self.hierarchy_size[d + 1],
+					self.hierarchy_structure[d][1]
+				)
+				cuda.Context.synchronize()
+			elif self.hierarchy_structure[d][0] == OR_GROUP:
+				self.evaluate_or_groups.prepared_call(
+					self.grid,
+					self.block,
+					self.hierarchy_votes[d-1],
+					self.hierarchy_votes[d],
+					self.hierarchy_size[d + 1],
+					self.hierarchy_structure[d][1]
+				)
+				cuda.Context.synchronize()
+			elif self.hierarchy_structure[d][0] == OR_ALTERNATIVES:
+				self.evaluate_or_alternatives.prepared_call(
+					self.grid,
+					self.block,
+					self.hierarchy_votes[d-1],
+					self.hierarchy_votes[d],
+					self.hierarchy_size[d + 1],
+					self.hierarchy_structure[d][1]
+				)
+				cuda.Context.synchronize()
+			else:
+				printf("Unknown node type!")
+				sys.exit()
+
+		# Adds up the votes from each clause (hierarchy root)
+		self.evaluate_final.prepared_call(
+			self.grid,
+			self.block,
+			np.int32(self.number_of_outputs),
+			self.hierarchy_votes[self.depth-1],
+			self.clause_weights_gpu,
+			self.class_sum_gpu
+		)
+		cuda.Context.synchronize()
+
+	def _fit(self, X, encoded_Y, epochs=100, incremental=False):
+		number_of_examples = X.shape[0]
+
+		if self.first:
+			# Allocates memory and prepares weights and Tsetlin automata states on first run 
+			self.allocate_gpu_memory()
+
+			self.initialize_weights_and_ta_states()
+
+			self.first = False
+		elif not incremental:
+			# Re-initializes weights and Tsetlin automata states if training is not incremental
+			self.initialize_weights_and_ta_states()
+
+		# Allocates GPU memory for training data
+		encoded_X_hierarchy_training_gpu = cuda.mem_alloc(int(number_of_examples * self.number_of_literal_chunks * 4))
+		Y_gpu = cuda.mem_alloc(encoded_Y.nbytes)
+
+		self.encode_X(X, encoded_X_hierarchy_training_gpu)
+		cuda.memcpy_htod(Y_gpu, encoded_Y)
+
+		for epoch in range(epochs):
+			for e in range(number_of_examples):
+				self.evaluate_hierarchy(encoded_X_hierarchy_training_gpu, e)
+
+				# Propagates the root value and any intermittent node values back to the leaves.
+				# The purpose is to determine which leaves only has True nodes on the path from leaf to root.
+				for d in range(self.depth-1, 0, -1):
+					self.propagate_and_group_false_truth_values.prepared_call(
+						self.grid,
+						self.block,
+						self.hierarchy_votes[d-1],
+						self.hierarchy_votes[d],
+						self.hierarchy_size[d + 1],
+						self.hierarchy_structure[d][1]
+					)
+					cuda.Context.synchronize()
+
+				# Updates the clause components (leaves) based on the propagated truth values
+				self.update_hierarchy.prepared_call(
+					self.grid,
+					self.block,
+					g.state,
+					np.int32(self.number_of_outputs),
+					self.ta_state_hierarchy_gpu,
+					self.clause_weights_gpu,
+					self.hierarchy_votes[0],
+					self.depth,
+					self.hierarchy_structure_factors_gpu,
+					self.hierarchy_structure_alternatives_gpu,
+					self.class_sum_gpu,
+					encoded_X_hierarchy_training_gpu,
+					Y_gpu,
+					np.int32(e)
+				)
+				cuda.Context.synchronize()
+
+				# Updates the clause weights
+				if (self.tm_type in [WEIGHTED_TM, COALESCED_TM]):
+					self.update_weights.prepared_call(
+						self.grid,
+						self.block,
+						g.state,
+						np.int32(self.tm_type),
+						np.int32(self.number_of_outputs),
+						self.clause_weights_gpu,
+						self.hierarchy_votes[self.depth-1],
+						self.class_sum_gpu,
+						Y_gpu,
+						np.int32(e)
+					)
+					cuda.Context.synchronize()
+		return
+       
+	def _score(self, X):
+		number_of_examples = X.shape[0]
+		
+		encoded_X_hierarchy_test_gpu = cuda.mem_alloc(int(number_of_examples * self.number_of_literal_chunks * 4))
+		self.encode_X(X, encoded_X_hierarchy_test_gpu)
+
+		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)
+
+		for e in range(number_of_examples):
+			self.evaluate_hierarchy(encoded_X_hierarchy_test_gpu, e)
+
+			cuda.memcpy_dtoh(class_sum_example, self.class_sum_gpu)
+			class_sum[:, e] = class_sum_example
+		
+		class_sum = np.clip(class_sum.reshape((self.number_of_outputs, number_of_examples)), -self.T, self.T)
+
+		return class_sum
+	
+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)):
+		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)
+
+	def fit(self, X, Y, epochs=100, incremental=False):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+
+		self.number_of_outputs = Y.shape[1]
+		self.patch_dim = (X.shape[1], 1, 1)
+
+		self.max_y = None
+		self.min_y = None
+		
+		encoded_Y = np.where(Y == 1, self.T, -self.T).astype(np.int32)
+		self._fit(X, encoded_Y, epochs = epochs, incremental = incremental)
+
+		return
+
+	def score(self, X):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+		return self._score(X)
+
+	def predict(self, X):
+		return (self.score(X) >= 0).astype(np.uint32).transpose()
+
+class MultiClassTsetlinMachine(CommonTsetlinMachine):
+	def __init__(self, number_of_clauses, T, s, tm_type=VANILLA_TM, 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)):
+		self.negative_clauses = 1
+		super().__init__(number_of_clauses, T, s, tm_type=tm_type, 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)
+
+	def fit(self, X, Y, epochs=100, incremental=False):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+
+		self.number_of_outputs = int(np.max(Y) + 1)
+		self.patch_dim = (X.shape[1], 1, 1)
+
+		self.max_y = None
+		self.min_y = None
+		
+		encoded_Y = np.empty((Y.shape[0], self.number_of_outputs), dtype = np.int32)
+		for i in range(self.number_of_outputs):
+			encoded_Y[:,i] = np.where(Y == i, self.T, -self.T)
+
+		self._fit(X, encoded_Y, epochs = epochs, incremental = incremental)
+
+		return
+
+	def score(self, X):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+		return self._score(X)
+
+	def predict(self, X):
+		return np.argmax(self.score(X), axis=0)
+
+class TsetlinMachine(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)):
+		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)
+
+	def fit(self, X, Y, epochs=100, incremental=False):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+
+		self.number_of_outputs = 1
+		self.patch_dim = (X.shape[1], 1, 1)
+		
+		self.max_y = None
+		self.min_y = None
+		
+		encoded_Y = np.where(Y == 1, self.T, -self.T).astype(np.int32)
+
+		self._fit(X, encoded_Y, epochs = epochs, incremental = incremental)
+
+		return
+
+	def score(self, X):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+		return self._score(X)[0,:]
+
+	def predict(self, X):
+		return int(self.score(X) >= 0)
+
+class RegressionTsetlinMachine(CommonTsetlinMachine):
+	def __init__(self, number_of_clauses, T, s, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1)):
+		self.negative_clauses = 0
+		super().__init__(number_of_clauses, T, s, boost_true_positive_feedback=boost_true_positive_feedback, number_of_state_bits=number_of_state_bits, append_negated=append_negated, grid=grid, block=block)
+
+	def fit(self, X, Y, epochs=100, incremental=False):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+		
+		self.number_of_outputs = 1
+		self.patch_dim = (X.shape[1], 1, 1)
+
+		self.max_y = np.max(Y)
+		self.min_y = np.min(Y)
+	
+		encoded_Y = ((Y - self.min_y)/(self.max_y - self.min_y)*self.T).astype(np.int32)
+			
+		self._fit(X, encoded_Y, epochs = epochs, incremental = incremental)
+
+		return
+
+	def predict(self, X):
+		X = X.reshape(X.shape[0], X.shape[1], 1)
+		
+		return 1.0*(self._score(X)[0,:])*(self.max_y - self.min_y)/(self.T) + self.min_y

pyhierarchicaltsetlinmachinecuda-0.2.0/PyHierarchicalTsetlinMachineCUDA/tools.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from sklearn.preprocessing import FunctionTransformer
+from sklearn.preprocessing import KBinsDiscretizer
+
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# From https://github.com/WojciechMigda/Tsetlini/blob/main/lib/examples/california-housing/src/produce_dataset_alt.py
+
+def _as_bits(x, nbits):
+	s = '1' * x + '0' * (nbits - x)
+	return np.array([int(c) for c in s])
+
+def _unpack_bits(a, nbits):
+	if len(a.shape) > 2:
+		raise ValueError("_unpack_bits: input array cannot have more than 2 dimensions, got {}".format(len(a.shape)))
+
+	a = np.clip(a, 0, nbits)
+	a_ = np.empty_like(a, dtype=np.uint64)
+	np.rint(a, out=a_, casting='unsafe')
+	F = np.frompyfunc(_as_bits, 2, 1)
+	rv = np.stack(F(a_.ravel(), nbits)).reshape(a.shape[0], -1)
+	return rv
+
+class Booleanizer:
+	def __init__(self,  max_bits_per_feature = 25):
+		self.max_bits_per_feature = max_bits_per_feature
+
+		self.kbd = KBinsDiscretizer(n_bins=max_bits_per_feature+1, encode='ordinal', strategy='quantile')
+
+		return
+
+	def fit(self, X):
+		self.kbd_fitted = self.kbd.fit(X)
+		
+		return
+
+	def transform(self, X):
+		X_transformed = self.kbd_fitted.transform(X).astype(int)
+
+		pre = FunctionTransformer(_unpack_bits, validate=False, kw_args={'nbits': self.max_bits_per_feature})
+		return pre.fit_transform(X_transformed)

pyhierarchicaltsetlinmachinecuda-0.2.0/README.md

@@ -0,0 +1,33 @@
+# PyHierarchicalTsetlinMachineCUDA
+Implements the Hierarchical Tsetlin Machine in CUDA
+
+## Installation
+
+```bash
+python ./setup.py sdist
+pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.0.tar.gz 
+```
+
+## 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.0/pyhierarchicaltsetlinmachinecuda.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pyhierarchicaltsetlinmachinecuda
+Version: 0.2.0
+Summary: Hierarchical Tsetlin Machine Architecture.
+Home-page: https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/
+Author: Ole-Christoffer Granmo
+Author-email: ole.granmo@uia.no
+License: MIT
+Keywords: pattern-recognition cuda machine-learning interpretable-machine-learning rule-based-machine-learning propositional-logic tsetlin-machine regression convolution classification multi-layer
+License-File: LICENSE
+
+Hierarchical Tsetlin Machine Architecture.

pyhierarchicaltsetlinmachinecuda-0.2.0/pyhierarchicaltsetlinmachinecuda.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+PyHierarchicalTsetlinMachineCUDA/__init__.py
+PyHierarchicalTsetlinMachineCUDA/graph.py
+PyHierarchicalTsetlinMachineCUDA/kernels.py
+PyHierarchicalTsetlinMachineCUDA/tm.py
+PyHierarchicalTsetlinMachineCUDA/tools.py
+pyhierarchicaltsetlinmachinecuda.egg-info/PKG-INFO
+pyhierarchicaltsetlinmachinecuda.egg-info/SOURCES.txt
+pyhierarchicaltsetlinmachinecuda.egg-info/dependency_links.txt
+pyhierarchicaltsetlinmachinecuda.egg-info/top_level.txt

pyhierarchicaltsetlinmachinecuda-0.2.0/pyhierarchicaltsetlinmachinecuda.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyhierarchicaltsetlinmachinecuda-0.2.0/pyhierarchicaltsetlinmachinecuda.egg-info/top_level.txt

@@ -0,0 +1 @@
+PyHierarchicalTsetlinMachineCUDA

pyhierarchicaltsetlinmachinecuda-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyhierarchicaltsetlinmachinecuda-0.2.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import *
+
+setup(
+   name='pyhierarchicaltsetlinmachinecuda',
+   version='0.2.0',
+   author='Ole-Christoffer Granmo',
+   author_email='ole.granmo@uia.no',
+   url='https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/',
+   license='MIT',
+   description='Hierarchical Tsetlin Machine Architecture.',
+   long_description='Hierarchical Tsetlin Machine Architecture.',
+   keywords ='pattern-recognition cuda machine-learning interpretable-machine-learning rule-based-machine-learning propositional-logic tsetlin-machine regression convolution classification multi-layer',
+   packages=['PyHierarchicalTsetlinMachineCUDA']
+)