PyHierarchicalTsetlinMachineCUDA 0.3.0__tar.gz → 0.3.2__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -94,8 +94,14 @@ code_update = """
 
 			int sign = (*clause_weight >= 0) - (*clause_weight < 0);
 		
-			float absolute_prediction_error = fabsf(y - class_sum);
-			if (curand_uniform(localState) <= 1.0*absolute_prediction_error/(2*THRESHOLD)) {
+			float update_probability;
+			#if CONSTANT_UPDATE_P == 1
+				update_probability = 1.0;
+			#else
+				update_probability = fabsf(y - class_sum)/(2*THRESHOLD);
+			#endif
+
+			if (curand_uniform(localState) <= update_probability) {
 				if (target*sign > 0) {
 					if (clause_output && abs(*clause_weight) < INT_MAX) {
 						(*clause_weight) += sign;
@@ -124,8 +130,14 @@ code_update = """
 
 			int sign = (*clause_weight >= 0) - (*clause_weight < 0);
 		
-			float absolute_prediction_error = fabsf(y - class_sum);
-			if (curand_uniform(localState) <= 1.0*absolute_prediction_error/(2*THRESHOLD)) {
+			float update_probability;
+			#if CONSTANT_UPDATE_P == 1
+				update_probability = 1.0;
+			#else
+				update_probability = fabsf(y - class_sum)/(2*THRESHOLD);
+			#endif
+
+			if (curand_uniform(localState) <= update_probability) {
 				if (target*sign > 0) {
 					// Type I Feedback
 					for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF; ++ta_chunk) {
@@ -199,31 +211,19 @@ code_update = """
 
 				// Evaluate clause component
 
-				#if LOG_SCALE == 1
-					float component_output = 0;
-				#else
-					float component_output = 1;
-				#endif
+				float 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[feature_chunk_base + ta_chunk]) != ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1]) {
-						#if LOG_SCALE == 1
-							component_output = NEG_INFINITY;
-						#else
-							component_output = 0;
-						#endif
+						component_output = 0;
 							
 						break;
 					}
 				}
 
 				if ((ta_state[(TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS - 1] & Xi[feature_chunk_base + TA_CHUNKS_PER_LEAF-1] & FILTER_HIERARCHICAL) != (ta_state[(TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS - 1] & FILTER_HIERARCHICAL)) {
-					#if LOG_SCALE == 1
-						component_output = NEG_INFINITY;
-					#else
-						component_output = 0;
-					#endif
+					component_output = 0;
 				}
 
 				global_component_output[clause_component] = component_output;
@@ -262,17 +262,12 @@ code_update = """
 			for (int and_group_node = index; and_group_node < CLAUSES*number_of_and_group_nodes; and_group_node += stride) {
 				// Multiply and factors
 
-				#if LOG_SCALE == 1
-					float and_group_vote_product = 0;
-				#else
-					float and_group_vote_product = 1;
-				#endif
-
+				float 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
 					
-					#if LOG_SCALE == 1
-				 		and_group_vote_product += child_input[and_group_node*number_of_and_group_factors + and_factor];
+					#if AND_GROUP_NORMALIZATION == 1
+						and_group_vote_product *= powf(child_input[and_group_node*number_of_and_group_factors + and_factor], 1.0/number_of_and_group_factors);
 				 	#else
 				 		and_group_vote_product *= child_input[and_group_node*number_of_and_group_factors + and_factor];
 				 	#endif	
@@ -289,24 +284,14 @@ code_update = """
 			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 LOG_SCALE == 1
-					if (group_node_output[group_node] == NEG_INFINITY) {
-						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] = NEG_INFINITY;	
-							}
-						}
-					}		
-				#else
-					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;	
-							}
+			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;	
 						}
 					}
-				#endif
+				}
 
 				if (group_node_output[group_node] == -1) {
 					for (int and_factor = 0; and_factor < number_of_group_node_children; ++and_factor) {
@@ -321,63 +306,50 @@ code_update = """
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
 
-			int non_zero_children[MAX_NUMBER_OF_OR_GROUP_CHILDREN];
+			int child_input_sum;
 
 			/* Copy state to local memory for efficiency */  
 			curandState localState = state[index];
 
 			// 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) {
-				int number_of_non_zero_children = 0;
-
-				#if LOG_SCALE == 1
-					if (group_node_output[group_node] == -1) {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							child_input[group_node*number_of_group_node_children + or_addend] = -1;	
-						}
-					}  else if (group_node_output[group_node] == NEG_INFINITY) {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							if (child_input[group_node*number_of_group_node_children + or_addend] >= 0) {
-								child_input[group_node*number_of_group_node_children + or_addend] = NEG_INFINITY;	
-							}
-						}
-					} else {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							if (child_input[group_node*number_of_group_node_children + or_addend] >= 0) {
-								non_zero_children[number_of_non_zero_children] = or_addend;
-								number_of_non_zero_children++;
-							}
-						}
+				if (group_node_output[group_node] == -1) {
+					for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
+						child_input[group_node*number_of_group_node_children + or_addend] = -1;	
 					}
-				#else
-					if (group_node_output[group_node] == -1) {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							child_input[group_node*number_of_group_node_children + or_addend] = -1;	
-						}
-					}  else if (group_node_output[group_node] == 0) {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							if (child_input[group_node*number_of_group_node_children + or_addend] > 0) {
-								child_input[group_node*number_of_group_node_children + or_addend] = 0;	
-							}
+				}  else if (group_node_output[group_node] == 0) {
+					for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
+						if (child_input[group_node*number_of_group_node_children + or_addend] > 0) {
+							child_input[group_node*number_of_group_node_children + or_addend] = 0;	
 						}
-					} else {
-						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
-							if (child_input[group_node*number_of_group_node_children + or_addend] > 0) { // Or pick the largest.... picking randomly when a tie
-								non_zero_children[number_of_non_zero_children] = or_addend;
-								number_of_non_zero_children++;
-							}
+					}
+				} else {
+					child_input_sum = 0;
+					for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
+						if (child_input[group_node*number_of_group_node_children + or_addend] > 0) {
+							child_input_sum += child_input[group_node*number_of_group_node_children + or_addend];
 						}
 					}
-				#endif
+				}
 
+				// Skip node if "turned off" (-1)
 				if (group_node_output[group_node] != -1) {
 					int selected_child;
-					if (number_of_non_zero_children > 0) {
-						selected_child = non_zero_children[curand(&localState) % number_of_non_zero_children];
+					if (group_node_output[group_node] > 0) {
+						int random_child_value = curand(&localState) % child_input_sum;
+						child_input_sum = 0;
+						for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
+							child_input_sum += child_input[group_node*number_of_group_node_children + or_addend];
+							if (child_input_sum > random_child_value) {
+								selected_child = or_addend;
+								break;
+							}
+						}
 					} else {
 						selected_child = curand(&localState) % number_of_group_node_children;
 					}
 					
+					// "Turn off" the sub-hierarchies that were not selected 
 					for (int or_addend = 0; or_addend < number_of_group_node_children; ++or_addend) {
 						if (selected_child != or_addend) {
 							child_input[group_node*number_of_group_node_children + or_addend] = -1;
@@ -397,39 +369,15 @@ code_update = """
 
 			// 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) {
-				#if LOG_SCALE == 1
-					float or_alternatives_vote_max = NEG_INFINITY;
-					for (int or_alternative = 0; or_alternative < number_of_or_alternatives; ++or_alternative) {
-						if (child_input[or_alternatives_node * number_of_or_alternatives + or_alternative] > or_alternatives_vote_max) {
-							or_alternatives_vote_max = child_input[or_alternatives_node * number_of_or_alternatives + or_alternative];
-						}
-					}
-
-					if (or_alternatives_vote_max != NEG_INFINITY) {
-						// Sum up votes from each or alternative
-						float or_alternatives_vote_sum = 0;
-						for (int or_alternative = 0; or_alternative < number_of_or_alternatives; ++or_alternative) {
-							// Aggregates or alternatives through summation
-							
-							or_alternatives_vote_sum += exp2f(child_input[or_alternatives_node * number_of_or_alternatives + or_alternative] - or_alternatives_vote_max);
-						}
-
-						// Store vote sum as node output
-						or_alternatives_node_output[or_alternatives_node] = or_alternatives_vote_max + log2f(or_alternatives_vote_sum);
-					} else {
-						or_alternatives_node_output[or_alternatives_node] = NEG_INFINITY;
-					}
-				#else
-					// 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];
-					}
+				// 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];
+				}
 
-					// Store vote sum as node output
-					or_alternatives_node_output[or_alternatives_node] = or_alternatives_vote_sum;
-				#endif
+				// Store vote sum as node output
+				or_alternatives_node_output[or_alternatives_node] = or_alternatives_vote_sum;
 			}
 		}
 
@@ -450,41 +398,18 @@ code_update = """
 			int stride = blockDim.x * gridDim.x;
 
 			// Add up the votes from each clause
-			#if LOG_SCALE == 1
-				// Add up the votes from each clause
-				for (int class_id = index; class_id < number_of_outputs; class_id += stride) {
-					float clause_output_max = NEG_INFINITY;
-					for (int clause = 0; clause < CLAUSES; ++clause) {
-						if (clause_output[clause] > clause_output_max) {
-							clause_output_max = clause_output[clause];
-						}
-					}
-
-					if (clause_output_max != NEG_INFINITY) {
-						float weighted_clause_output_sum = 0;
-						for (int clause = 0; clause < CLAUSES; ++clause) {
-							weighted_clause_output_sum += clause_weights[class_id*CLAUSES + clause] * exp2f(clause_output[clause] - clause_output_max);
-						}
 
-						if (log2f(fabs(weighted_clause_output_sum)) + clause_output_max >= log2f(THRESHOLD)) {
-							float sign = (1 - 2 * (weighted_clause_output_sum < 0));
-							class_sum[class_id] = sign*THRESHOLD;
-						} else {
-							class_sum[class_id] = weighted_clause_output_sum * exp2f(clause_output_max);
-						}
-					} else {
-						class_sum[class_id] = 0;
-					}
-				}
-			#else
-				for (int clause = index; clause < CLAUSES; clause += stride) {
-					if (clause_output[clause]) {
-						for (int class_id = 0; class_id < number_of_outputs; ++class_id) {
+			for (int clause = index; clause < CLAUSES; clause += stride) {
+				if (clause_output[clause]) {
+					for (int class_id = 0; class_id < number_of_outputs; ++class_id) {
+						#if BINARY_INFERENCE == 0
 							atomicAdd(&class_sum[class_id], (float) clause_weights[class_id*CLAUSES + clause] * clause_output[clause]);
-						}	
-					}
+						#else
+							atomicAdd(&class_sum[class_id], (float) clause_weights[class_id*CLAUSES + clause]);
+						#endif
+					}	
 				}
-			#endif
+			}
 		}
 
 		__global__ void rescale_final(int number_of_outputs, float *clause_output_max, float *class_sum)
@@ -563,11 +488,7 @@ code_update = """
 						local_class_sum = -THRESHOLD;
 					}
 
-					#if LOG_SCALE == 1
-						update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component] != NEG_INFINITY, &Xi[feature_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
-					#else
-						update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component] > 0, &Xi[feature_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
-					#endif
+					update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component] > 0, &Xi[feature_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
 				}
 			}
 		
@@ -592,11 +513,7 @@ code_update = """
 						local_class_sum = -THRESHOLD;
 					}
 
-					#if LOG_SCALE == 1
-						update_clause_weight(&localState, tm_type, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], clause_output[clause] != NEG_INFINITY, y[example*number_of_outputs + class_id], local_class_sum);
-					#else
-						update_clause_weight(&localState, tm_type, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], clause_output[clause] > 0, y[example*number_of_outputs + class_id], local_class_sum);
-					#endif
+					update_clause_weight(&localState, tm_type, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], clause_output[clause] > 0, y[example*number_of_outputs + class_id], local_class_sum);
 				}
 			}
 		

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/PyHierarchicalTsetlinMachineCUDA/tm.py

@@ -25,7 +25,7 @@ import PyHierarchicalTsetlinMachineCUDA.kernels as kernels
 
 import pycuda.curandom as curandom
 import pycuda.driver as cuda
-import pycuda.autoinit
+import pycuda.autoprimaryctx
 from pycuda.compiler import SourceModule
 from pycuda import gpuarray
 from pycuda.gpuarray import GPUArray 
@@ -44,13 +44,16 @@ COALESCED_TM = 2
 
 class CommonTsetlinMachine():
 
-	def __init__(self, number_of_clauses, T, s, q=1.0, log_scale=False, 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):
+	def __init__(self, number_of_clauses, T, s, q=1.0, no_clipping=False, constant_update_p=0, binary_inference=False, and_group_normalization=False, 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)
+		self.T = float(T)
 		self.s = s
 		self.q = q
-		self.log_scale = log_scale
+		self.no_clipping = no_clipping
+		self.constant_update_p = constant_update_p
+		self.binary_inference = binary_inference
+		self.and_group_normalization = and_group_normalization
 		self.hierarchy_structure = hierarchy_structure
 		self.depth = len(hierarchy_structure)
 
@@ -97,12 +100,6 @@ class CommonTsetlinMachine():
 			if self.hierarchy_structure[d][0] != OR_GROUP: # OR_GROUP reuses the same TA
 				self.number_of_ta_teams = self.hierarchy_structure[self.depth - d - 1][1] * self.number_of_ta_teams
 
-		# Identifies the larget number of OR_GROUP children (for allocating local memory)
-		self.max_number_of_or_group_children = 0
-		for d in range(1, self.depth):
-			if self.hierarchy_structure[d][0] == OR_GROUP and self.max_number_of_or_group_children < self.hierarchy_structure[d][1]:
-				self.max_number_of_or_group_children = self.hierarchy_structure[d][1]
-
 		# Calculates number of literal chunks overall for the feature vector (ignores OR- and AND alternatives)
 		self.number_of_literal_chunks = self.number_of_literal_chunks_per_leaf
 		for d in range(self.depth - 1, 0, -1):
@@ -133,19 +130,19 @@ class CommonTsetlinMachine():
 	#define S %f
 	#define THRESHOLD %d
 	#define Q %f
-	#define LOG_SCALE %d
+	#define BINARY_INFERENCE %d
+	#define CONSTANT_UPDATE_P %d
+	#define AND_GROUP_NORMALIZATION %d
 
 	#define AND_GROUP %d
 	#define AND_ALTERNATIVES %d
 	#define OR_GROUP %d
 	#define OR_ALTERNATIVES %d
 
-	#define MAX_NUMBER_OF_OR_GROUP_CHILDREN %d
-
 	#define NEGATIVE_CLAUSES %d
 	#define FLIP_POLARITY %d
-		""" % (self.number_of_clauses, self.depth, self.hierarchy_size[1], self.number_of_ta_teams, 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.log_scale, AND_GROUP, AND_ALTERNATIVES, OR_GROUP, OR_ALTERNATIVES, self.max_number_of_or_group_children, self.negative_clauses, self.flip_polarity)
-		
+		""" % (self.number_of_clauses, self.depth, self.hierarchy_size[1], self.number_of_ta_teams, 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.binary_inference, self.constant_update_p, self.and_group_normalization, AND_GROUP, AND_ALTERNATIVES, OR_GROUP, OR_ALTERNATIVES, self.negative_clauses, self.flip_polarity)
+
 		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")
@@ -337,15 +334,6 @@ class CommonTsetlinMachine():
 		self.clause_output_max[:] = np.finfo(np.float32).min
 		cuda.memcpy_htod(self.clause_output_max_gpu, self.clause_output_max)
 
-		# if self.log_scale:
-		# 	self.max_clause_output.prepared_call(
-		# 		self.grid,
-		# 		self.block,
-		# 		np.int32(self.number_of_outputs),
-		# 		self.hierarchy_votes[self.depth-1],
-		# 		self.clause_output_max_gpu
-		# 	)
-
 		# Adds up the votes from each clause (hierarchy root)
 		self.evaluate_final.prepared_call(
 			self.grid,
@@ -356,15 +344,6 @@ class CommonTsetlinMachine():
 			self.class_sum_gpu
 		)
 
-		# if self.log_scale:
-		# 	self.rescale_final.prepared_call(
-		# 		self.grid,
-		# 		self.block,
-		# 		np.int32(self.number_of_outputs),
-		# 		self.clause_output_max_gpu,
-		# 		self.class_sum_gpu
-		# 	)
-
 	def _fit(self, X, encoded_Y):
 		if self.number_of_features_hierarchy != X.shape[1]:
 			print("The number of features spanned by hierarchy does not align with the input data.")
@@ -453,15 +432,18 @@ class CommonTsetlinMachine():
 		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 = np.ascontiguousarray(np.zeros((self.number_of_outputs, number_of_examples))).astype(np.float32)
 
 		for e in range(number_of_examples):
 			self.evaluate_hierarchy(encoded_X_hierarchy_test_gpu, e)
 
 			cuda.memcpy_dtoh(self.class_sum, self.class_sum_gpu)
-			class_sum[:, e] = self.class_sum.astype(np.int32)
+			class_sum[:, e] = self.class_sum
 	
-		class_sum = np.clip(class_sum.reshape((self.number_of_outputs, number_of_examples)), -self.T, self.T)
+		if self.no_clipping:
+			class_sum = class_sum.reshape((self.number_of_outputs, number_of_examples))
+		else:
+			class_sum = np.clip(class_sum.reshape((self.number_of_outputs, number_of_examples)), -self.T, self.T)
 
 		return class_sum
 
@@ -508,7 +490,7 @@ class CommonTsetlinMachine():
 				continue
 
 			n_children = self.hierarchy_structure[level][1]
-			is_alt = (self.hierarchy_structure[level][0] == OR_ALTERNATIVES)
+			is_alt = self.hierarchy_structure[level][0] in (OR_ALTERNATIVES, AND_ALTERNATIVES)
 			for child_pos in range(n_children):
 				child_id = node_id * n_children + child_pos
 				if is_alt:
@@ -607,12 +589,12 @@ class CommonTsetlinMachine():
 					if self.ta_action(i, j, k):
 						if (not self.append_negated) or k < self.number_of_literals_per_leaf // 2:
 							if print_ta_state:
-								l.append("x%d(%d)" % (feature_base + k, self.ta_state(i, j, k)))
+								l.append("x%d[%d]" % (feature_base + k, self.ta_state(i, j, k)))
 							else:
 								l.append("x%d" % (feature_base + k,))
 						else:
 							if print_ta_state:
-								l.append("¬x%d(%d)" % (feature_base + k - self.number_of_literals_per_leaf // 2, self.ta_state(i, j, k)))
+								l.append("¬x%d[%d]" % (feature_base + k - self.number_of_literals_per_leaf // 2, self.ta_state(i, j, k)))
 							else:
 								l.append("¬x%d" % (feature_base + k - self.number_of_literals_per_leaf // 2,))
 				
@@ -666,9 +648,9 @@ class CommonTsetlinMachine():
 
 	
 class MultiOutputTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, q=1.0, log_scale=False, boost_true_positive_feedback=1, number_of_state_bits=8, append_negated=True, grid=(16*13,1,1), block=(128,1,1), seed=None):
+	def __init__(self, number_of_clauses, T, s, q=1.0, no_clipping=False, constant_update_p=0, binary_inference=False, and_group_normalization=False, 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, log_scale=log_scale, 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)
+		super().__init__(number_of_clauses, T, s, q=q, no_clipping=no_clipping, constant_update_p=constant_update_p, binary_inference=binary_inference, and_group_normalization=and_group_normalization, 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):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -692,12 +674,12 @@ class MultiOutputTsetlinMachine(CommonTsetlinMachine):
 		return (self.score(X) >= 0).astype(np.uint32).transpose()
 
 class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, q=1.0, log_scale=False, 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):
+	def __init__(self, number_of_clauses, T, s, q=1.0, no_clipping=False, constant_update_p=0, binary_inference=False, and_group_normalization=False, 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 = 1
 		self.tm_type = COALESCED_TM
 		self.flip_polarity = 1
 
-		super().__init__(number_of_clauses, T, s, q=q, log_scale=log_scale, 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)
+		super().__init__(number_of_clauses, T, s, q=q, no_clipping=no_clipping, constant_update_p=constant_update_p, binary_inference=binary_inference, and_group_normalization=and_group_normalization, 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):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -724,12 +706,15 @@ class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
 		return np.argmax(self.score(X), axis=0)
 
 class MultiClassTsetlinMachine:
-	def __init__(self, number_of_clauses, T, s, q=1.0, log_scale=False, weighted_clauses=False, 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):
+	def __init__(self, number_of_clauses, T, s, q=1.0, no_clipping=False, constant_update_p=0, binary_inference=False, and_group_normalization=False, weighted_clauses=False, 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.number_of_clauses = number_of_clauses
 		self.T = T
 		self.s = s
 		self.q = q
-		self.log_scale = log_scale
+		self.no_clipping = no_clipping
+		self.constant_update_p = constant_update_p
+		self.binary_inference = binary_inference
+		self.and_group_normalization = and_group_normalization
 		self.weighted_clauses = weighted_clauses
 		self.hierarchy_structure = hierarchy_structure
 		self.boost_true_positive_feedback = boost_true_positive_feedback
@@ -747,7 +732,7 @@ class MultiClassTsetlinMachine:
 		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, q=self.q, log_scale=self.log_scale, 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, seed=self.seed+i))
+				self.tms.append(TsetlinMachine(self.number_of_clauses, self.T, self.s, q=self.q, no_clipping=self.no_clipping, constant_update_p=self.constant_update_p, binary_inference=self.binary_inference, and_group_normalization=self.and_group_normalization, 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, seed=self.seed+i))
 
 			self.configured = True
 
@@ -768,7 +753,7 @@ class MultiClassTsetlinMachine:
 		return
 
 	def score(self, X):
-		class_sums = np.empty((self.number_of_outputs, X.shape[0]), dtype=np.int32)
+		class_sums = np.empty((self.number_of_outputs, X.shape[0]), dtype=np.float32)
 		for i in range(self.number_of_outputs):
 			class_sums[i,:] = self.tms[i].score(X)
 
@@ -798,7 +783,7 @@ class MultiClassTsetlinMachine:
 
 	def print_hierarchy(self, print_ta_state=False):
 		for i in range(self.number_of_outputs):
-			print("CLASS %d\n", i)
+			print("\nCLASS %d\n" % (i,))
 			self.tms[i].print_hierarchy(print_ta_state = print_ta_state)
 
 	def load(self, state_dict: dict):
@@ -813,7 +798,7 @@ class MultiClassTsetlinMachine:
 		self.configured = True
 
 class TsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, q=1.0, log_scale=False, weighted_clauses=False, 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):
+	def __init__(self, number_of_clauses, T, s, q=1.0, no_clipping=False, constant_update_p=0, binary_inference=False, and_group_normalization=False, weighted_clauses=False, 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 = 1
 		self.flip_polarity = 0
 
@@ -822,7 +807,7 @@ class TsetlinMachine(CommonTsetlinMachine):
 		else:
 			self.tm_type = VANILLA_TM
 
-		super().__init__(number_of_clauses, T, s, q=q, log_scale=log_scale, 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)
+		super().__init__(number_of_clauses, T, s, q=q, no_clipping=no_clipping, constant_update_p=constant_update_p, binary_inference=binary_inference, and_group_normalization=and_group_normalization, 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):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
@@ -846,11 +831,11 @@ class TsetlinMachine(CommonTsetlinMachine):
 		return (self.score(X) >= 0).astype(np.int32)
 
 class RegressionTsetlinMachine(CommonTsetlinMachine):
-	def __init__(self, number_of_clauses, T, s, log_scale=False, 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):
+	def __init__(self, number_of_clauses, T, s, and_group_normalization=False, 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, log_scale=log_scale, 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)
+		super().__init__(number_of_clauses, T, s, and_group_normalization=and_group_normalization, 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):
 		X = X.reshape(X.shape[0], X.shape[1], 1)

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/PyHierarchicalTsetlinMachineCUDA/utils.py

@@ -3,17 +3,31 @@ from collections import deque
 import networkx as nx
 import numpy as np
 
-from .tm import OR_ALTERNATIVES, CommonTsetlinMachine
+from .tm import AND_ALTERNATIVES, AND_GROUP, OR_ALTERNATIVES, OR_GROUP, CommonTsetlinMachine
 
+DEFAULT_NODE_TYPE_LABELS: dict[int, str] = {
+	AND_GROUP: ' ∧* ',
+	AND_ALTERNATIVES: ' ∧ ',
+	OR_GROUP: ' ∨* ',
+	OR_ALTERNATIVES: ' ∨ ',
+}
 
-def make_hierarchy_graph(G: nx.Graph, hier: list[tuple[int, int]]):
+
+def make_hierarchy_graph(
+	G: nx.Graph,
+	hier: list[tuple[int, int]],
+	node_type_labels: dict[int, str] | None = None,
+):
 	"""Create Graph from the hierarchy."""
+	node_type_labels = {**DEFAULT_NODE_TYPE_LABELS, **(node_type_labels or {})}
+
 	# 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])
+		op = hier[level - 1][0]
+		G.add_node((level, idx), label=node_type_labels.get(op, op), op=op)
 		if level == 1:
 			continue
 		branching = hier[level - 1][1]
@@ -29,6 +43,7 @@ def clause_to_nx(
 	negation_prefix: str = '¬',
 	clause_literals: np.ndarray | None = None,
 	ta_to_fid_mapping=None,
+	node_type_labels: dict[int, str] | None = None,
 ):
 	"""
 	Create a networkx Graph for a single clause.
@@ -39,6 +54,7 @@ def clause_to_nx(
 		`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.
+		`node_type_labels`: Optional dict overriding the display symbol for one or more hierarchy node types (`AND_GROUP`/`AND_ALTERNATIVES`/`OR_GROUP`/`OR_ALTERNATIVES`). Merged over `DEFAULT_NODE_TYPE_LABELS`; unset keys fall back to the default.
 	"""
 
 	assert tm.hierarchy_structure is not None, (
@@ -62,7 +78,7 @@ def clause_to_nx(
 	lits_per_comp = tm.number_of_literals_per_leaf
 
 	G = nx.Graph()
-	make_hierarchy_graph(G, tm.hierarchy_structure)
+	make_hierarchy_graph(G, tm.hierarchy_structure, node_type_labels)
 
 	feat_per_comp = lits_per_comp // 2 if tm.append_negated else lits_per_comp
 
@@ -95,6 +111,7 @@ def clause_bank_to_nx(
 	tm: CommonTsetlinMachine,
 	feature_names: list[str] | None = None,
 	negation_prefix: str = '¬',
+	node_type_labels: dict[int, str] | None = None,
 ):
 	"""
 	Create a networkx Graph for the entire clause bank.
@@ -102,15 +119,18 @@ def clause_bank_to_nx(
 		`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: '¬').
+		`node_type_labels`: Optional dict overriding the display symbol for one or more hierarchy node types. Merged over `DEFAULT_NODE_TYPE_LABELS`; unset keys fall back to the default.
 	"""
+	node_type_labels = {**DEFAULT_NODE_TYPE_LABELS, **(node_type_labels or {})}
+
 	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)
+	G.add_node(cb_root, label=node_type_labels.get(OR_ALTERNATIVES, 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
+			tm, ci, feature_names, negation_prefix, literals[ci], ta_to_fid, node_type_labels
 		)
 		mapping = {node: (ci, node) for node in clause_G.nodes}
 		G = nx.compose(G, nx.relabel_nodes(clause_G, mapping))
@@ -124,6 +144,7 @@ def active_path_graph(
 	X: np.ndarray,
 	feature_names: list[str] | None = None,
 	negation_prefix: str = '¬',
+	node_type_labels: dict[int, str] | None = None,
 ):
 	"""
 	Show the activated path, and vote calculation for a single sample `X`.
@@ -132,6 +153,7 @@ def active_path_graph(
 		`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: '¬').
+		`node_type_labels`: Optional dict overriding the display symbol for one or more hierarchy node types. Merged over `DEFAULT_NODE_TYPE_LABELS`; unset keys fall back to the 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.
 	"""
@@ -139,7 +161,7 @@ def active_path_graph(
 
 	hierarchy_votes, class_sums = tm.calc_hierarchy_votes(X.reshape(1, -1))
 	hierarchy_votes = hierarchy_votes[0]
-	class_sums = class_sums[0]
+	class_sums = class_sums[:, 0]
 
 	literals = tm.get_literals()
 	ta_to_fid = tm.map_ta_id_to_feature_id()
@@ -147,7 +169,7 @@ def active_path_graph(
 	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)
+		clause_to_nx(tm, ci, feature_names, negation_prefix, literals[ci], ta_to_fid, node_type_labels)
 		for ci in range(tm.number_of_clauses)
 	]
 	for ci in range(tm.number_of_clauses):

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/README.md

@@ -11,7 +11,7 @@ or
 git clone git@github.com:cair/PyHierarchicalTsetlinMachineCUDA.git
 cd PyHierarchicalTsetlinMachineCUDA
 python ./setup.py sdist
-pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.8.tar.gz 
+pip install dist/PyHierarchicalTsetlinMachineCUDA-0.3.1.tar.gz 
 ```
 
 ## Examples
@@ -79,7 +79,7 @@ CLAUSE 1: (((((x0 ∧ x1) ∨ (x0 ∧ x1) ∨ (¬x0 ∧ ¬x1)) ∧ ((x3 ∧ x4)
 ### Hex Demo
 
 <p align="center">
-  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/hex_description/figures/Hex-board-11x11.png">
+  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/main/figures/Hex-board-11x11.png">
 </p>
 <p align="center">
 Source: https://en.wikipedia.org/wiki/Hex_(board_game)

{PyHierarchicalTsetlinMachineCUDA-0.3.0 → PyHierarchicalTsetlinMachineCUDA-0.3.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import *
 
 setup(
    name='PyHierarchicalTsetlinMachineCUDA',
-   version='0.3.0',
+   version='0.3.2',
    author='Ole-Christoffer Granmo',
    author_email='ole.granmo@uia.no',
    url='https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/',