PyHierarchicalTsetlinMachineCUDA 0.3.1__tar.gz → 0.3.3__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.3.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.3.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -41,6 +41,21 @@ code_header = """
 code_update = """
 	extern "C"
     {
+
+    	// Counts number of include actions for a given clause component
+	    __device__ inline int number_of_include_actions(unsigned int *ta_state)
+	    {
+	        int number_of_include_actions = 0;
+	        for (int k = 0; k < TA_CHUNKS_PER_LEAF-1; ++k) {
+	            unsigned int ta_pos = k*STATE_BITS + STATE_BITS-1;
+	            number_of_include_actions += __popc(ta_state[ta_pos]);
+	        }
+	        unsigned int ta_pos = (TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS-1;
+	        number_of_include_actions += __popc(ta_state[ta_pos] & FILTER_HIERARCHICAL);
+
+	        return(number_of_include_actions);
+	    }
+
     	// 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)
 		{
@@ -94,8 +109,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,10 +145,19 @@ 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
+
+					int included_literals = number_of_include_actions(ta_state);
+
 					for (int ta_chunk = 0; ta_chunk < TA_CHUNKS_PER_LEAF; ++ta_chunk) {
 						// Generate random bit values
 						unsigned int la_feedback = 0;
@@ -137,7 +167,7 @@ code_update = """
 							}
 						}
 
-						if (component_output) {
+						if (component_output && included_literals <= LITERAL_BUDGET) {
 							#if BOOST_TRUE_POSITIVE_FEEDBACK == 1
 								inc(ta_state, ta_chunk, X[ta_chunk]);
 							#else
@@ -199,31 +229,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 +280,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 +302,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) {
@@ -328,50 +331,29 @@ code_update = """
 
 			// 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] == -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 {
-						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 += np.exp2f(child_input[group_node*number_of_group_node_children + or_addend]); // Needs normalization
-							}
-						}
+				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 {
-						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];
-							}
+					}
+				} 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 (child_input_sum > 0) {
+					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) {
@@ -405,39 +387,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;
 			}
 		}
 
@@ -458,41 +416,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)
@@ -571,11 +506,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);
 				}
 			}
 		
@@ -600,11 +531,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.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/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,17 @@ 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, literal_budget=None, 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.literal_budget = literal_budget
+		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)
 
@@ -89,6 +93,9 @@ class CommonTsetlinMachine():
 			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)
 
+		if self.literal_budget == None:
+			self.literal_budget = self.number_of_literals_per_leaf
+
 		# 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]
 
@@ -127,7 +134,10 @@ class CommonTsetlinMachine():
 	#define S %f
 	#define THRESHOLD %d
 	#define Q %f
-	#define LOG_SCALE %d
+	#define LITERAL_BUDGET %d
+	#define BINARY_INFERENCE %d
+	#define CONSTANT_UPDATE_P %d
+	#define AND_GROUP_NORMALIZATION %d
 
 	#define AND_GROUP %d
 	#define AND_ALTERNATIVES %d
@@ -136,8 +146,8 @@ class CommonTsetlinMachine():
 
 	#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.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.literal_budget, 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")
@@ -329,15 +339,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,
@@ -348,15 +349,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.")
@@ -445,15 +437,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
 
@@ -500,7 +495,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:
@@ -599,12 +594,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,))
 				
@@ -658,9 +653,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, literal_budget=None, 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, literal_budget=literal_budget, 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)
@@ -684,12 +679,29 @@ 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,
+		literal_budget=None,
+		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, literal_budget=literal_budget, 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)
@@ -716,12 +728,16 @@ 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, literal_budget=None, 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.literal_budget = literal_budget
+		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
@@ -739,7 +755,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, literal_budget=self.literal_budget, 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
 
@@ -760,7 +776,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)
 
@@ -790,7 +806,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):
@@ -805,7 +821,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, literal_budget=None, 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
 
@@ -814,7 +830,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, literal_budget=literal_budget, 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)
@@ -838,11 +854,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, literal_budget=None, 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, literal_budget=literal_budget, 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.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/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.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.3.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/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.1 → PyHierarchicalTsetlinMachineCUDA-0.3.3}/setup.py

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