PyHierarchicalTsetlinMachineCUDA 0.2.8__tar.gz → 0.2.9__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -114,36 +114,6 @@ code_update = """
 			}
 		}
 
-		__device__ inline void update_clause_weight_old(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
-
-					(*clause_weight) -= sign;
-					
-					#if FLIP_POLARITY == 0
-						if (*clause_weight == 0) {
-							*clause_weight += sign;
-						}
-					#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, float class_sum)
 		{
 			int target = 1 - 2*(class_sum > y);
@@ -189,52 +159,6 @@ code_update = """
 			}
 		}
 
-		__device__ inline void update_component_hierarchy_old(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, float *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_type, int *X, int example)
 		{
@@ -254,22 +178,24 @@ code_update = """
 				int size_feature_chunk_base = 1;
 				int size_ta_chunk_base = 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];
+					int depth_d_node_index = component_remainder % hierarchy_structure_factors[d]; // Extract local index of node at depth d (the child index)
+					component_remainder = component_remainder / hierarchy_structure_factors[d]; // Move up the hierarchy to prepare for finding the local node index at depth d+1
 
-					if (hierarchy_structure_type[d] != 1) {
-						feature_chunk_base += size_feature_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size_feature_chunk_base *= hierarchy_structure_factors[d];
+					// Support multiple Tsetlin Automata teams operating on the same feature chunks to create alternatives.
+					if ((hierarchy_structure_type[d] != OR_ALTERNATIVES) && (hierarchy_structure_type[d] != AND_ALTERNATIVES)) {
+						feature_chunk_base += size_feature_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF; // Identify correct part of the sub-hierarchy (through flattening)
+						size_feature_chunk_base *= hierarchy_structure_factors[d]; // Identify how many nodes to jump to skip from one child to the next when indexing at the next depth level
 					}
 
-					if (hierarchy_structure_type[d] != 2) {
+					// Support reuse of the same Tsetlin Automata when doing OR to group different feature chunks
+					if (hierarchy_structure_type[d] != OR_GROUP) {
 						ta_chunk_base += size_ta_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
 						size_ta_chunk_base *= hierarchy_structure_factors[d];
 					}
 				}
 
 				// Get state of current ta team component
-				unsigned int *ta_state = &global_ta_state[clause*COMPONENTS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
+				unsigned int *ta_state = &global_ta_state[clause*TA_TEAMS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
 
 				// Evaluate clause component
 
@@ -304,60 +230,6 @@ code_update = """
 			}
 		}
 
-		// Evaluate example
-		__global__ void evaluate_leaves_old(unsigned int *global_ta_state, int *component_weights, float *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_type, 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;
-
-				int component_remainder = component;
-				int feature_chunk_base = 0;
-				int ta_chunk_base = 0;
-				int size_feature_chunk_base = 1;
-				int size_ta_chunk_base = 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_type[d] != 1) {
-						feature_chunk_base += size_feature_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size_feature_chunk_base *= hierarchy_structure_factors[d];
-					}
-
-					if (hierarchy_structure_type[d] != 2) {
-						ta_chunk_base += size_ta_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size_ta_chunk_base *= hierarchy_structure_factors[d];
-					}
-				}
-
-				// Get state of current ta team component
-				unsigned int *ta_state = &global_ta_state[clause*COMPONENTS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
-
-				// 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[feature_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[feature_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(float *child_input, float *or_group_node_output, int number_of_or_group_nodes, int number_of_or_group_addends)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
@@ -410,38 +282,6 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_and_groups_old(float *child_input, float *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;
-				int max_vote_sum = 0;
-				for (int and_factor = 0; and_factor < number_of_and_group_factors; ++and_factor) {
-					// Aggregate votes from each child node through multiplication
-					
-					int previous_and_group_vote_product = and_group_vote_product;
-					and_group_vote_product *= child_input[and_group_node*number_of_and_group_factors + and_factor];
-
-					if (child_input[and_group_node*number_of_and_group_factors + and_factor] > max_vote_sum) {
-						max_vote_sum = child_input[and_group_node*number_of_and_group_factors + and_factor];
-					}
-
-					if (and_group_vote_product < 0) {
-						printf("AND OVERFLOW %d -> %d\\n", previous_and_group_vote_product, and_group_vote_product);						
-						and_group_vote_product = previous_and_group_vote_product;
-					}
-				}
-
-				// Store and group product as node output
-				and_group_node_output[and_group_node] = and_group_vote_product;
-				//and_group_node_output[and_group_node] = max_vote_sum;
-			}
-		}
-
 		__global__ void propagate_and_group_false_truth_values(float *child_input, float *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
 		//__global__ void propagate_and_group_false_truth_values_log(int *child_input, int *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
 		{
@@ -476,23 +316,6 @@ code_update = """
 			}
 		}
 
-		__global__ void propagate_and_group_false_truth_values_old(float *child_input, float *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 propagate_or_group_false_truth_values(curandState *state, float *child_input, float *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
@@ -539,7 +362,7 @@ code_update = """
 						}
 					} 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) {
+							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++;
 							}
@@ -566,58 +389,6 @@ code_update = """
 			state[index] = localState;
 		}
 
-		__global__ void propagate_or_group_false_truth_values_old(curandState *state, float *child_input, float *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;
-
-			int non_zero_children[361];
-
-			/* 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 (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 {
-					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) {
-					int selected_child;
-					if (number_of_non_zero_children > 0) {
-						selected_child = non_zero_children[curand(&localState) % number_of_non_zero_children];
-					} else {
-						selected_child = curand(&localState) % number_of_group_node_children;
-					}
-					
-					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;
-						}
-					}
-				}
-			}
-
-			state[index] = localState;
-		}
-
 		__global__ void evaluate_or_alternatives(float *child_input, float *or_alternatives_node_output, int number_of_or_alternatives_nodes, int number_of_or_alternatives)
 		//__global__ void evaluate_or_alternatives_log(int *child_input, int *or_alternatives_node_output, int number_of_or_alternatives_nodes, int number_of_or_alternatives)
 		{
@@ -662,34 +433,6 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_or_alternatives_old(float *child_input, float *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
-					
-
-					int previous_or_alternatives_vote_sum = or_alternatives_vote_sum;
-					or_alternatives_vote_sum += child_input[or_alternatives_node * number_of_or_alternatives + or_alternative];
-
-					if (or_alternatives_vote_sum < 0) {
-						printf("OR OVERFLOW %d -> %d\\n", previous_or_alternatives_vote_sum, or_alternatives_vote_sum);
-						or_alternatives_vote_sum = previous_or_alternatives_vote_sum;
-					}
-				}
-
-				// Store vote sum as node output
-				or_alternatives_node_output[or_alternatives_node] = or_alternatives_vote_sum;
-			}
-		}
-
-
 		__global__ void max_clause_output(int number_of_outputs, float *clause_output, float *clause_output_max)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
@@ -701,19 +444,36 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_final(int number_of_outputs, float *clause_output, float *clause_output_max, int *clause_weights, float *class_sum)
+		__global__ void evaluate_final(int number_of_outputs, float *clause_output, int *clause_weights, float *class_sum)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
 
 			// Add up the votes from each clause
 			#if LOG_SCALE == 1
-				if (clause_output_max[0] != NEG_INFINITY) {
-					for (int clause = index; clause < CLAUSES; clause += stride) {
-						int output = exp2f(clause_output[clause] - clause_output_max[0]);
-						for (int class_id = 0; class_id < number_of_outputs; ++class_id) {
-							atomicAdd(&class_sum[class_id], (float) clause_weights[class_id*CLAUSES + clause] * output);
+				// 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
@@ -727,22 +487,6 @@ code_update = """
 			#endif
 		}
 
-		__global__ void evaluate_final_old(int number_of_outputs, float *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], (int) clause_weight * child_input[clause]);					
-					}
-				}
-			}
-		}
-
 		__global__ void rescale_final(int number_of_outputs, float *clause_output_max, float *class_sum)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
@@ -797,19 +541,19 @@ code_update = """
 					int depth_d_node_index = component_remainder % hierarchy_structure_factors[d];
 					component_remainder = component_remainder / hierarchy_structure_factors[d];
 
-					if (hierarchy_structure_type[d] != 1) {
+					if ((hierarchy_structure_type[d] != OR_ALTERNATIVES) && (hierarchy_structure_type[d] != AND_ALTERNATIVES)) {
 						feature_chunk_base += size_feature_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
 						size_feature_chunk_base *= hierarchy_structure_factors[d];
 					}
 
-					if (hierarchy_structure_type[d] != 2) {
+					if (hierarchy_structure_type[d] != OR_GROUP) {
 						ta_chunk_base += size_ta_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
 						size_ta_chunk_base *= hierarchy_structure_factors[d];
 					}
 				}
 
 				// Get state of current ta team component
-				unsigned int *ta_state = &global_ta_state[clause*COMPONENTS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
+				unsigned int *ta_state = &global_ta_state[clause*TA_TEAMS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
 
 				for (unsigned long long class_id = 0; class_id < number_of_outputs; ++class_id) {
 					float local_class_sum = class_sum[class_id];
@@ -830,68 +574,6 @@ code_update = """
 			state[index] = localState;
 		}
 
-		// Update state of Tsetlin Automata team
-		__global__ void update_hierarchy_old(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, float *component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_type, 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) {
-				if (component_output[clause_component] == -1) {
-					continue;
-				}
-
-				int clause = clause_component / COMPONENTS;
-				int component = clause_component % COMPONENTS;
-
-				// Get state of current clause component
-				// This one must be updated for reuse of TAs within OR group
-
-				int component_remainder = component;
-				int feature_chunk_base = 0;
-				int ta_chunk_base = 0;
-				int size_feature_chunk_base = 1;
-				int size_ta_chunk_base = 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_type[d] != 1) {
-						feature_chunk_base += size_feature_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size_feature_chunk_base *= hierarchy_structure_factors[d];
-					}
-
-					if (hierarchy_structure_type[d] != 2) {
-						ta_chunk_base += size_ta_chunk_base * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size_ta_chunk_base *= hierarchy_structure_factors[d];
-					}
-				}
-
-				// Get state of current ta team component
-				unsigned int *ta_state = &global_ta_state[clause*COMPONENTS*TA_CHUNKS_PER_LEAF*STATE_BITS + ta_chunk_base*STATE_BITS];
-
-				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, (int) component_output[clause_component], &Xi[feature_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, float *clause_output, float *class_sum, int *y, int example)
 		{
@@ -920,37 +602,13 @@ code_update = """
 		
 			state[index] = localState;
 		}
-
-		// Update state of Tsetlin Automata team
-		__global__ void update_weights_old(curandState *state, int tm_type, int number_of_outputs, int *clause_weights, float *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], (int) 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)
+		__global__ void prepare_weights(curandState *state, int tm_type, int number_of_outputs, int *clause_weights)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -974,17 +632,14 @@ code_prepare = """
 			state[index] = localState;
 		}
 
-		__global__ void prepare_hierarchy(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, int *class_sum)
+		__global__ void prepare_hierarchy(int number_of_outputs, unsigned int *global_ta_state)
 		{
 			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 clause_team = index; clause_team < CLAUSES*TA_TEAMS; clause_team += stride) {
+				// Get state of current ta team
+				unsigned int *ta_state = &global_ta_state[clause_team*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;
@@ -992,8 +647,6 @@ code_prepare = """
 					ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1] = 0;
 				}
 			}
-
-			state[index] = localState;
 		}
 	}
 """
@@ -1062,9 +715,9 @@ code_clauses = """
 		int index = blockIdx.x * blockDim.x + threadIdx.x;
 		int stride = blockDim.x * gridDim.x;
 
-		for (unsigned long long i = index; i < 1LLU * CLAUSES * COMPONENTS * LITERALS_PER_LEAF; i += stride) {
-			unsigned long long clause = i / (COMPONENTS * LITERALS_PER_LEAF);
-			unsigned long long comp   = (i / LITERALS_PER_LEAF) % COMPONENTS;
+		for (unsigned long long i = index; i < 1LLU * CLAUSES * TA_TEAMS * LITERALS_PER_LEAF; i += stride) {
+			unsigned long long clause = i / (TA_TEAMS * LITERALS_PER_LEAF);
+			unsigned long long comp   = (i / LITERALS_PER_LEAF) % TA_TEAMS;
 			unsigned long long ta_idx = i % LITERALS_PER_LEAF;
 
 			int chunk   = ta_idx / 32;
@@ -1073,14 +726,14 @@ code_clauses = """
 			unsigned int state = 0;
 			for (int b = 0; b < STATE_BITS; ++b) {
 				unsigned int plane = global_ta_state[
-					(clause * COMPONENTS * TA_CHUNKS_PER_LEAF * STATE_BITS) +
+					(clause * TA_TEAMS * TA_CHUNKS_PER_LEAF * STATE_BITS) +
 					(comp   * TA_CHUNKS_PER_LEAF * STATE_BITS) +
 					(chunk  * STATE_BITS) + b
 				];
 				if (plane & (1U << bit_pos)) state |= (1U << b);
 			}
 
-			unpacked_states[(clause * COMPONENTS * LITERALS_PER_LEAF) + (comp * LITERALS_PER_LEAF) + ta_idx] = state;
+			unpacked_states[(clause * TA_TEAMS * LITERALS_PER_LEAF) + (comp * LITERALS_PER_LEAF) + ta_idx] = state;
 		}
 	}
 """

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/PyHierarchicalTsetlinMachineCUDA/tm.py

@@ -33,15 +33,15 @@ import sys
 
 from time import time
 
-OR_GROUP = " ∨* "
-OR_ALTERNATIVES = " ∨ "
-AND_GROUP = " ∧ "
+AND_GROUP = 0
+AND_ALTERNATIVES = 1
+OR_GROUP = 2
+OR_ALTERNATIVES = 3
 
 VANILLA_TM = 0
 WEIGHTED_TM = 1
 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):
@@ -69,11 +69,8 @@ class CommonTsetlinMachine():
 		self.hierarchy_structure_factors = [0] * (self.depth - 1)
 		self.hierarchy_structure_type = [0] * (self.depth - 1)
 		for d in range(1, self.depth):
+			self.hierarchy_structure_type[d-1] = self.hierarchy_structure[d][0]
 			self.hierarchy_structure_factors[d-1] = self.hierarchy_structure[d][1]
-			if self.hierarchy_structure[d][0] == OR_ALTERNATIVES:
-				self.hierarchy_structure_type[d-1] = 1
-			elif self.hierarchy_structure[d][0] == OR_GROUP:
-				self.hierarchy_structure_type[d-1] = 2
 
 		# Calculates total number of features spanned by the hierarchy
 		self.number_of_features_hierarchy = 1
@@ -95,7 +92,12 @@ class CommonTsetlinMachine():
 		# 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_ta_teams = 1
+		for d in range(self.depth - 1):
+			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
+
+		# 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):
 			if (self.hierarchy_structure[d][0] == OR_GROUP or self.hierarchy_structure[d][0] == AND_GROUP):
@@ -116,6 +118,7 @@ class CommonTsetlinMachine():
 	#define CLAUSES %d
 	#define DEPTH %d
 	#define COMPONENTS %d
+	#define TA_TEAMS %d
 	#define LITERALS_PER_LEAF %d
 	#define TA_CHUNKS_PER_LEAF %d
 	#define LITERAL_CHUNKS %d
@@ -126,9 +129,14 @@ class CommonTsetlinMachine():
 	#define Q %f
 	#define LOG_SCALE %d
 
+	#define AND_GROUP %d
+	#define AND_ALTERNATIVES %d
+	#define OR_GROUP %d
+	#define OR_ALTERNATIVES %d
+
 	#define NEGATIVE_CLAUSES %d
 	#define FLIP_POLARITY %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.log_scale, 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.log_scale, 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")
@@ -148,7 +156,7 @@ class CommonTsetlinMachine():
 		self.max_clause_output.prepare("iPP")
 
 		self.evaluate_final = mod_update.get_function("evaluate_final")
-		self.evaluate_final.prepare("iPPPP")
+		self.evaluate_final.prepare("iPPP")
 
 		self.rescale_final = mod_update.get_function("rescale_final")
 		self.rescale_final.prepare("iPP")
@@ -186,11 +194,9 @@ class CommonTsetlinMachine():
 
 		# 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
@@ -209,7 +215,7 @@ class CommonTsetlinMachine():
 		cuda.memcpy_htod(self.hierarchy_structure_type_gpu, np.array(self.hierarchy_structure_type, 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.ta_state_hierarchy_gpu = cuda.mem_alloc(self.number_of_clauses*self.number_of_ta_teams*self.number_of_literal_chunks_per_leaf*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)
@@ -218,16 +224,16 @@ class CommonTsetlinMachine():
 		self.clause_output_max = np.ascontiguousarray(np.empty(1)).astype(np.float32)
 
 	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)
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.number_of_ta_teams*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 = ta_state_hierarchy.reshape((self.number_of_clauses, self.hierarchy_size[1], self.number_of_literal_chunks_per_leaf, self.number_of_state_bits))
+		ta_state_hierarchy = ta_state_hierarchy.reshape((self.number_of_clauses, self.number_of_ta_teams, self.number_of_literal_chunks_per_leaf, self.number_of_state_bits))
 
 		return (ta_state_hierarchy[clause, leaf, ta // 32, self.number_of_state_bits-1] & (1 << (ta % 32))) > 0
 
 	def ta_state(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)
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.number_of_ta_teams*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 = ta_state_hierarchy.reshape((self.number_of_clauses, self.hierarchy_size[1], self.number_of_literal_chunks_per_leaf, self.number_of_state_bits))
+		ta_state_hierarchy = ta_state_hierarchy.reshape((self.number_of_clauses, self.number_of_ta_teams, self.number_of_literal_chunks_per_leaf, self.number_of_state_bits))
 		
 		state = 0
 		for b in range(self.number_of_state_bits):
@@ -238,7 +244,7 @@ class CommonTsetlinMachine():
 
 	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)
+		ta_state_hierarchy = np.empty(self.number_of_clauses*self.number_of_ta_teams*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)
@@ -255,7 +261,7 @@ class CommonTsetlinMachine():
 		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.ta_state_hierarchy_gpu = cuda.mem_alloc(self.number_of_clauses*self.number_of_ta_teams*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])
@@ -265,15 +271,13 @@ class CommonTsetlinMachine():
 		None # To be updated
 
 	def initialize_weights_and_ta_states(self):
-		self.prepare_weights(self.cuda_rng.state, np.int32(self.tm_type), np.int32(self.number_of_outputs), self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
-		cuda.Context.synchronize()
+		self.prepare_weights(self.cuda_rng.state, np.int32(self.tm_type), np.int32(self.number_of_outputs), self.clause_weights_gpu, grid=self.grid, block=self.block)
 
-		self.prepare_hierarchy(self.cuda_rng.state, np.int32(self.number_of_outputs), self.ta_state_hierarchy_gpu, self.clause_weights_gpu, self.class_sum_gpu, grid=self.grid, block=self.block)
-		cuda.Context.synchronize()
+		self.prepare_hierarchy(np.int32(self.number_of_outputs), self.ta_state_hierarchy_gpu, grid=self.grid, block=self.block)
 
 	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)
+		class_sum = np.zeros(self.number_of_outputs, dtype=np.float32)
 		cuda.memcpy_htod(self.class_sum_gpu, class_sum)
 
 		# Evaluates all the hierarchy leaves in parallel
@@ -289,11 +293,10 @@ class CommonTsetlinMachine():
 			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):
+			if (self.hierarchy_structure[d][0] == AND_GROUP or self.hierarchy_structure[d][0] == AND_ALTERNATIVES):
 				self.evaluate_and_groups.prepared_call(
 					self.grid,
 					self.block,
@@ -302,7 +305,6 @@ class CommonTsetlinMachine():
 					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,
@@ -312,7 +314,6 @@ class CommonTsetlinMachine():
 					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,
@@ -322,23 +323,20 @@ class CommonTsetlinMachine():
 					self.hierarchy_size[d + 1],
 					self.hierarchy_structure[d][1]
 				)
-				cuda.Context.synchronize()
 			else:
-				printf("Unknown node type!")
-				sys.exit()
+				raise ValueError("Unknown Node Type!")
 
 		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
-			)
-			cuda.Context.synchronize()
+		# 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(
@@ -346,23 +344,20 @@ class CommonTsetlinMachine():
 			self.block,
 			np.int32(self.number_of_outputs),
 			self.hierarchy_votes[self.depth-1],
-			self.clause_output_max_gpu,
 			self.clause_weights_gpu,
 			self.class_sum_gpu
 		)
-		cuda.Context.synchronize()
 
-		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
-			)
-			cuda.Context.synchronize()
+		# 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, epochs=100, incremental=False):
+	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.")
 			sys.exit(-1)
@@ -376,10 +371,7 @@ class CommonTsetlinMachine():
 			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)
@@ -387,69 +379,64 @@ class CommonTsetlinMachine():
 		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):
-					if self.hierarchy_structure[d][0] != OR_GROUP:
-						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()
-					else:
-						self.propagate_or_group_false_truth_values.prepared_call(
-							self.grid,
-							self.block,
-							self.cuda_rng.state,
-							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(
+		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):
+				if self.hierarchy_structure[d][0] != OR_GROUP:
+					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]
+					)
+				else:
+					self.propagate_or_group_false_truth_values.prepared_call(
+						self.grid,
+						self.block,
+						self.cuda_rng.state,
+						self.hierarchy_votes[d-1],
+						self.hierarchy_votes[d],
+						self.hierarchy_size[d + 1],
+						self.hierarchy_structure[d][1]
+					)
+
+			# Updates the clause components (leaves) based on the propagated truth values
+			self.update_hierarchy.prepared_call(
+				self.grid,
+				self.block,
+				self.cuda_rng.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_type_gpu,
+				self.class_sum_gpu,
+				encoded_X_hierarchy_training_gpu,
+				Y_gpu,
+				np.int32(e)
+			)
+
+			# Updates the clause weights
+			if (self.tm_type in [WEIGHTED_TM, COALESCED_TM]):
+				self.update_weights.prepared_call(
 					self.grid,
 					self.block,
 					self.cuda_rng.state,
+					np.int32(self.tm_type),
 					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_type_gpu,
+					self.hierarchy_votes[self.depth-1],
 					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,
-						self.cuda_rng.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):
@@ -543,8 +530,8 @@ class CommonTsetlinMachine():
 		encoded_X_hierarchy_test_gpu = gpuarray.empty((number_of_examples, self.number_of_literal_chunks), dtype=np.uint32)
 		self.encode_X(X, encoded_X_hierarchy_test_gpu.gpudata)
 
-		class_sum = np.ascontiguousarray(np.zeros((self.number_of_outputs, number_of_examples))).astype(np.int32)
-		class_sum_example = np.ascontiguousarray(np.zeros(self.number_of_outputs)).astype(np.int32)
+		class_sum = np.zeros((self.number_of_outputs, number_of_examples), dtype=np.float32)
+		class_sum_example = np.zeros(self.number_of_outputs, dtype=np.float32)
 		hierarchy_votes = []
 		for e in range(number_of_examples):
 			self.evaluate_hierarchy(encoded_X_hierarchy_test_gpu.gpudata, e)
@@ -554,7 +541,7 @@ class CommonTsetlinMachine():
 
 			hierarchy_votes_example = []
 			for d in range(self.depth):
-				temp_arr = np.empty(self.number_of_clauses*int(self.hierarchy_size[d+1]), dtype=np.int32)
+				temp_arr = np.zeros(self.number_of_clauses*int(self.hierarchy_size[d+1]), dtype=np.float32)
 				cuda.memcpy_dtoh(temp_arr, self.hierarchy_votes[d])
 				hierarchy_votes_example.append(temp_arr.reshape((self.number_of_clauses, int(self.hierarchy_size[d+1]))))
 
@@ -581,7 +568,7 @@ class CommonTsetlinMachine():
 					depth_d_node_index = component_remainder % self.hierarchy_structure[d][1]
 					component_remainder = component_remainder // self.hierarchy_structure[d][1]
 
-					if self.hierarchy_structure[d][0] != OR_ALTERNATIVES:
+					if (self.hierarchy_structure[d][0] != OR_ALTERNATIVES) and (self.hierarchy_structure[d][0] != AND_ALTERNATIVES):
 						feature_base += size * depth_d_node_index 
 						size *= self.hierarchy_structure[d][1];
 
@@ -591,7 +578,10 @@ class CommonTsetlinMachine():
 						right.append(")")
 						left.insert(0, "(")
 					elif previous_index[d-1] != depth_d_node_index:
-						inside.append(self.hierarchy_structure[d][0])
+						if self.hierarchy_structure[d][0] in [AND_GROUP, AND_ALTERNATIVES]:
+							inside.append(" ∧ ")
+						elif self.hierarchy_structure[d][0] in [OR_GROUP, OR_ALTERNATIVES]:
+							inside.append(" ∨ ")
 					
 					previous_index[d-1] = depth_d_node_index
 
@@ -607,7 +597,7 @@ class CommonTsetlinMachine():
 				l = []
 				for k in range(self.number_of_literals_per_leaf):
 					if self.ta_action(i, j, k):
-						if k < self.number_of_literals_per_leaf // 2:
+						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)))
 							else:
@@ -672,7 +662,7 @@ class MultiOutputTsetlinMachine(CommonTsetlinMachine):
 		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)
 
-	def fit(self, X, Y, epochs=100, incremental=False):
+	def fit(self, X, Y):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
 
 		self.number_of_outputs = Y.shape[1]
@@ -682,7 +672,7 @@ class MultiOutputTsetlinMachine(CommonTsetlinMachine):
 		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)
+		self._fit(X, encoded_Y)
 
 		return
 
@@ -701,7 +691,7 @@ class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
 
 		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)
 
-	def fit(self, X, Y, epochs=100, incremental=False):
+	def fit(self, X, Y):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
 
 		self.number_of_outputs = int(np.max(Y) + 1)
@@ -714,7 +704,7 @@ class MultiClassCoalescedTsetlinMachine(CommonTsetlinMachine):
 		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)
+		self._fit(X, encoded_Y)
 
 		return
 
@@ -743,7 +733,7 @@ class MultiClassTsetlinMachine:
 
 		self.configured = False
 
-	def fit(self, X, Y, epochs=100, incremental=False):
+	def fit(self, X, Y):
 		self.number_of_outputs = int(np.max(Y) + 1)
 
 		if not self.configured:
@@ -755,19 +745,18 @@ class MultiClassTsetlinMachine:
 
 		encoded_Y = np.empty(Y.shape[0], dtype = np.int32)
 
-		for epoch in range(epochs):
-			for i in range(self.number_of_outputs):
-				target_X = X[Y==i]
+		for i in range(self.number_of_outputs):
+			target_X = X[Y==i]
 
-				not_target_X = X[Y!=i]
-				not_target_index = np.random.rand(not_target_X.shape[0]) <= 1.0/(self.number_of_outputs - 1)
+			not_target_X = X[Y!=i]
+			not_target_index = np.random.rand(not_target_X.shape[0]) <= 1.0/(self.number_of_outputs - 1)
 
-				balanced_X = np.vstack((target_X, not_target_X[not_target_index,:]))
-				balanced_Y = np.hstack((np.ones(target_X.shape[0]), np.zeros(not_target_X.shape[0])))
-				index = np.arange(balanced_X.shape[0])
-				np.random.shuffle(index)
+			balanced_X = np.vstack((target_X, not_target_X[not_target_index,:]))
+			balanced_Y = np.hstack((np.ones(target_X.shape[0]), np.zeros(not_target_X.shape[0])))
+			index = np.arange(balanced_X.shape[0])
+			np.random.shuffle(index)
 
-				self.tms[i].fit(balanced_X[index], balanced_Y[index], epochs=1, incremental=incremental)
+			self.tms[i].fit(balanced_X[index], balanced_Y[index])
 		return
 
 	def score(self, X):
@@ -799,6 +788,11 @@ class MultiClassTsetlinMachine:
 			},
 		}
 
+	def print_hierarchy(self, print_ta_state=False):
+		for i in range(self.number_of_outputs):
+			print("CLASS %d\n", i)
+			self.tms[i].print_hierarchy(print_ta_state = print_ta_state)
+
 	def load(self, state_dict: dict):
 		self.number_of_outputs = state_dict['number_of_outputs']
 
@@ -822,7 +816,7 @@ class TsetlinMachine(CommonTsetlinMachine):
 
 		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)
 
-	def fit(self, X, Y, epochs=100, incremental=False):
+	def fit(self, X, Y):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
 
 		self.number_of_outputs = 1
@@ -832,7 +826,7 @@ class TsetlinMachine(CommonTsetlinMachine):
 		
 		encoded_Y = np.where(Y == 1, self.T, -self.T).astype(np.int32)
 
-		self._fit(X, encoded_Y, epochs = epochs, incremental = incremental)
+		self._fit(X, encoded_Y)
 
 		return
 
@@ -850,7 +844,7 @@ class RegressionTsetlinMachine(CommonTsetlinMachine):
 
 		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)
 
-	def fit(self, X, Y, epochs=100, incremental=False):
+	def fit(self, X, Y):
 		X = X.reshape(X.shape[0], X.shape[1], 1)
 		
 		self.number_of_outputs = 1
@@ -861,7 +855,7 @@ class RegressionTsetlinMachine(CommonTsetlinMachine):
 	
 		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)
+		self._fit(X, encoded_Y)
 
 		return
 

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/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.6.tar.gz 
+pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.8.tar.gz 
 ```
 
 ## Examples

{PyHierarchicalTsetlinMachineCUDA-0.2.8 → PyHierarchicalTsetlinMachineCUDA-0.2.9}/setup.py

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