PyHierarchicalTsetlinMachineCUDA 0.2.3__tar.gz → 0.2.6__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -159,44 +159,52 @@ code_update = """
 		}
 
 		// Evaluate example
-		__global__ void evaluate_leaves(unsigned int *global_ta_state, int *component_weights, long long int *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_alternatives, int *X, int example)
+		__global__ void evaluate_leaves(unsigned int *global_ta_state, int *component_weights, int *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_type, int *X, int example)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
 
-			int *Xi = &X[(long long)example*LITERAL_CHUNKS];
+			int *Xi = &X[(unsigned long long)example*LITERAL_CHUNKS];
 
 			// Evaluate each clause component (leaf) in separate threads
 			for (int clause_component = index; clause_component < CLAUSES*COMPONENTS; clause_component += stride) {
+				int clause = clause_component / COMPONENTS;
 				int component = clause_component % COMPONENTS;
 
-				// Get state of current clause component
-				unsigned int *ta_state = &global_ta_state[clause_component*TA_CHUNKS_PER_LEAF*STATE_BITS];
-
 				int component_remainder = component;
+				int feature_chunk_base = 0;
 				int ta_chunk_base = 0;
-				int size = 1;
+				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_alternatives[d] == 0) {
-						ta_chunk_base += size * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size *= 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[ta_chunk_base + ta_chunk]) != ta_state[ta_chunk*STATE_BITS + STATE_BITS - 1]) {
+					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[ta_chunk_base + TA_CHUNKS_PER_LEAF-1] & FILTER_HIERARCHICAL) != (ta_state[(TA_CHUNKS_PER_LEAF-1)*STATE_BITS + STATE_BITS - 1] & FILTER_HIERARCHICAL)) {
+				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;
 				}
 
@@ -204,7 +212,7 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_or_groups(long long int *child_input, long long int *or_group_node_output, int number_of_or_group_nodes, int number_of_or_group_addends)
+		__global__ void evaluate_or_groups(int *child_input, int *or_group_node_output, int number_of_or_group_nodes, int number_of_or_group_addends)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -212,24 +220,30 @@ code_update = """
 			// Add up the votes of each OR node child
 			for (int or_group_node = index; or_group_node < CLAUSES*number_of_or_group_nodes; or_group_node += stride) {
 				// Add OR addends
-				long long int or_group_vote_sum = 0;
+				int or_group_vote_sum = 0;
+				int max_vote_sum = 0;
+        
 				for (int or_addend = 0; or_addend < number_of_or_group_addends; ++or_addend) {
 					// Aggregate votes from each child node through addition
 
-					long long int previous_or_group_vote_sum = or_group_vote_sum; 
+					if (child_input[or_group_node*number_of_or_group_addends + or_addend] > max_vote_sum) {
+						max_vote_sum = child_input[or_group_node*number_of_or_group_addends + or_addend];
+					}
+
+					int previous_or_group_vote_sum = or_group_vote_sum; 
 					or_group_vote_sum += child_input[or_group_node*number_of_or_group_addends + or_addend];
 					if (or_group_vote_sum < 0) {
-						printf("OR* OVERFLOW %lld -> %lld\\n", previous_or_group_vote_sum, or_group_vote_sum);						
+						printf("OR* OVERFLOW %d -> %d\\n", previous_or_group_vote_sum, or_group_vote_sum);						
 						or_group_vote_sum = previous_or_group_vote_sum;
 					}
 				}
 
-				// Store or group vote sum as node output
-				or_group_node_output[or_group_node] = or_group_vote_sum;
+				// or_group_node_output[or_group_node] = or_group_vote_sum;
+				or_group_node_output[or_group_node] = max_vote_sum;
 			}
 		}
 
-		__global__ void evaluate_and_groups(long long int *child_input, long long int *and_group_node_output, int number_of_and_group_nodes, int number_of_and_group_factors)
+		__global__ void evaluate_and_groups(int *child_input, int *and_group_node_output, int number_of_and_group_nodes, int number_of_and_group_factors)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -237,15 +251,15 @@ code_update = """
 			// 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
-				long long int and_group_vote_product = 1;
+				int and_group_vote_product = 1;
 				for (int and_factor = 0; and_factor < number_of_and_group_factors; ++and_factor) {
 					// Aggregate votes from each child node through multiplication
 					
-					long long int previous_and_group_vote_product = and_group_vote_product;
+					int previous_and_group_vote_product = and_group_vote_product;
 					and_group_vote_product *= child_input[and_group_node*number_of_and_group_factors + and_factor];
 
 					if (and_group_vote_product < 0) {
-						printf("AND OVERFLOW %lld -> %lld\\n", previous_and_group_vote_product, and_group_vote_product);						
+						printf("AND OVERFLOW %d -> %d\\n", previous_and_group_vote_product, and_group_vote_product);						
 						and_group_vote_product = previous_and_group_vote_product;
 					}
 				}
@@ -255,7 +269,7 @@ code_update = """
 			}
 		}
 
-		__global__ void propagate_and_group_false_truth_values(long long int *child_input, long long int *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
+		__global__ void propagate_and_group_false_truth_values(int *child_input, int *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -272,7 +286,59 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_or_alternatives(long long int *child_input, long long int *or_alternatives_node_output, int number_of_or_alternatives_nodes, int number_of_or_alternatives)
+		__global__ void propagate_or_group_false_truth_values(curandState *state, int *child_input, int *group_node_output, int number_of_group_nodes, int number_of_group_node_children)
+		{
+			int index = blockIdx.x * blockDim.x + threadIdx.x;
+			int stride = blockDim.x * gridDim.x;
+
+			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(int *child_input, int *or_alternatives_node_output, int number_of_or_alternatives_nodes, int number_of_or_alternatives)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -280,16 +346,16 @@ 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) {
 				// Sum up votes from each or alternative
-				long long int or_alternatives_vote_sum = 0;
+				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
 					
 
-					long long int previous_or_alternatives_vote_sum = or_alternatives_vote_sum;
+					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 %lld -> %lld\\n", previous_or_alternatives_vote_sum, or_alternatives_vote_sum);
+						printf("OR OVERFLOW %d -> %d\\n", previous_or_alternatives_vote_sum, or_alternatives_vote_sum);
 						or_alternatives_vote_sum = previous_or_alternatives_vote_sum;
 					}
 				}
@@ -299,7 +365,7 @@ code_update = """
 			}
 		}
 
-		__global__ void evaluate_final(int number_of_outputs, long long int *child_input, int *clause_weights, int *class_sum)
+		__global__ void evaluate_final(int number_of_outputs, int *child_input, int *clause_weights, int *class_sum)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -316,7 +382,7 @@ code_update = """
 		}
 
 		// Update state of Tsetlin Automata team
-		__global__ void update_hierarchy(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, long long int *component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_alternatives, int *class_sum, int *X, int *y, int example)
+		__global__ void update_hierarchy(curandState *state, int number_of_outputs, unsigned int *global_ta_state, int *clause_weights, int *component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_type, int *class_sum, int *X, int *y, int example)
 		{
 			int index = blockIdx.x * blockDim.x + threadIdx.x;
 			int stride = blockDim.x * gridDim.x;
@@ -328,25 +394,39 @@ code_update = """
 
 			// 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
-				unsigned int *ta_state = &global_ta_state[clause_component*TA_CHUNKS_PER_LEAF*STATE_BITS];
+				// 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 = 1;
+				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_alternatives[d] == 0) {
-						ta_chunk_base += size * depth_d_node_index * TA_CHUNKS_PER_LEAF;
-						size *= 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) {
@@ -355,7 +435,7 @@ code_update = """
 						local_class_sum = -THRESHOLD;
 					}
 
-					update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component], &Xi[ta_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
+					update_component_hierarchy(&localState, number_of_outputs, &clause_weights[class_id*CLAUSES + clause], ta_state, component_output[clause_component], &Xi[feature_chunk_base], y[example*number_of_outputs + class_id], local_class_sum);
 				}
 			}
 		

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PyHierarchicalTsetlinMachineCUDA/tm.py

@@ -28,6 +28,7 @@ import pycuda.driver as cuda
 import pycuda.autoinit
 from pycuda.compiler import SourceModule
 from pycuda import gpuarray
+import sys
 
 from time import time
 
@@ -64,11 +65,13 @@ class CommonTsetlinMachine():
 
 		# Represents hierarchy structure for transfer to GPU
 		self.hierarchy_structure_factors = [0] * (self.depth - 1)
-		self.hierarchy_structure_alternatives = [0] * (self.depth - 1)
+		self.hierarchy_structure_type = [0] * (self.depth - 1)
 		for d in range(1, self.depth):
 			self.hierarchy_structure_factors[d-1] = self.hierarchy_structure[d][1]
 			if self.hierarchy_structure[d][0] == OR_ALTERNATIVES:
-				self.hierarchy_structure_alternatives[d-1] = 1
+				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
@@ -147,6 +150,9 @@ class CommonTsetlinMachine():
 		self.propagate_and_group_false_truth_values = mod_update.get_function("propagate_and_group_false_truth_values")
 		self.propagate_and_group_false_truth_values.prepare("PPii")
 
+		self.propagate_or_group_false_truth_values = mod_update.get_function("propagate_or_group_false_truth_values")
+		self.propagate_or_group_false_truth_values.prepare("PPPii")
+
 		self.evaluate_or_groups = mod_update.get_function("evaluate_or_groups")
 		self.evaluate_or_groups.prepare("PPii")
 
@@ -189,8 +195,8 @@ class CommonTsetlinMachine():
 		cuda.memcpy_htod(self.hierarchy_structure_factors_gpu, np.array(self.hierarchy_structure_factors, dtype=np.int32))
 
 		# GPU memory for storing hierarchy structure
-		self.hierarchy_structure_alternatives_gpu = cuda.mem_alloc((self.depth-1)*4)
-		cuda.memcpy_htod(self.hierarchy_structure_alternatives_gpu, np.array(self.hierarchy_structure_alternatives, dtype=np.int32))
+		self.hierarchy_structure_type_gpu = cuda.mem_alloc((self.depth-1)*4)
+		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)
@@ -266,7 +272,7 @@ class CommonTsetlinMachine():
 			self.hierarchy_votes[0],
 			self.depth,
 			self.hierarchy_structure_factors_gpu,
-			self.hierarchy_structure_alternatives_gpu,
+			self.hierarchy_structure_type_gpu,
 			encoded_X_hierarchy,
 			np.int32(e)
 		)
@@ -320,6 +326,10 @@ class CommonTsetlinMachine():
 		cuda.Context.synchronize()
 
 	def _fit(self, X, encoded_Y, epochs=100, incremental=False):
+		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)
+
 		number_of_examples = X.shape[0]
 
 		if self.first:
@@ -347,15 +357,27 @@ class CommonTsetlinMachine():
 				# Propagates the root value and any intermittent node values back to the leaves.
 				# The purpose is to determine which leaves only has True nodes on the path from leaf to root.
 				for d in range(self.depth-1, 0, -1):
-					self.propagate_and_group_false_truth_values.prepared_call(
-						self.grid,
-						self.block,
-						self.hierarchy_votes[d-1],
-						self.hierarchy_votes[d],
-						self.hierarchy_size[d + 1],
-						self.hierarchy_structure[d][1]
-					)
-					cuda.Context.synchronize()
+					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(
@@ -368,7 +390,7 @@ class CommonTsetlinMachine():
 					self.hierarchy_votes[0],
 					self.depth,
 					self.hierarchy_structure_factors_gpu,
-					self.hierarchy_structure_alternatives_gpu,
+					self.hierarchy_structure_type_gpu,
 					self.class_sum_gpu,
 					encoded_X_hierarchy_training_gpu,
 					Y_gpu,

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PyHierarchicalTsetlinMachineCUDA.egg-info/SOURCES.txt

@@ -10,8 +10,4 @@ PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO
 PyHierarchicalTsetlinMachineCUDA.egg-info/SOURCES.txt
 PyHierarchicalTsetlinMachineCUDA.egg-info/dependency_links.txt
 PyHierarchicalTsetlinMachineCUDA.egg-info/requires.txt
-PyHierarchicalTsetlinMachineCUDA.egg-info/top_level.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/PKG-INFO
-pyhierarchicaltsetlinmachinecuda.egg-info/SOURCES.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/dependency_links.txt
-pyhierarchicaltsetlinmachinecuda.egg-info/top_level.txt
+PyHierarchicalTsetlinMachineCUDA.egg-info/top_level.txt

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/PyHierarchicalTsetlinMachineCUDA.egg-info/requires.txt

@@ -2,6 +2,7 @@ numpy
 pycuda
 scipy
 scikit-learn
+scikit-image
 networkx
 
 [examples]

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/README.md

@@ -149,11 +149,11 @@ python3 ./examples/HexDemo.py
 
 Accuracy over 1000 epochs:
 
-#1 Training Accuracy: 97.71% Testing Accuracy: 97.26% Training Time: 36.00s Testing Time: 5.65s
-#2 Training Accuracy: 99.11% Testing Accuracy: 98.61% Training Time: 33.65s Testing Time: 5.65s
-#3 Training Accuracy: 99.53% Testing Accuracy: 98.92% Training Time: 33.00s Testing Time: 5.65s
-#4 Training Accuracy: 99.74% Testing Accuracy: 99.18% Training Time: 32.66s Testing Time: 5.67s
-#5 Training Accuracy: 99.84% Testing Accuracy: 99.35% Training Time: 32.40s Testing Time: 5.67s
+#1 Training Accuracy: 97.98% Testing Accuracy: 97.46% Training Time: 37.02s Testing Time: 5.74s
+#2 Training Accuracy: 99.19% Testing Accuracy: 98.70% Training Time: 34.44s Testing Time: 5.76s
+#3 Training Accuracy: 99.49% Testing Accuracy: 98.92% Training Time: 33.60s Testing Time: 5.75s
+#4 Training Accuracy: 99.65% Testing Accuracy: 99.05% Training Time: 33.15s Testing Time: 5.78s
+#5 Training Accuracy: 99.73% Testing Accuracy: 99.10% Training Time: 32.86s Testing Time: 5.76s
 ...
 #446 Training Accuracy: 100.00% Testing Accuracy: 99.45% Training Time: 32.09s Testing Time: 6.09s
 #447 Training Accuracy: 100.00% Testing Accuracy: 99.46% Training Time: 32.08s Testing Time: 6.09s

{PyHierarchicalTsetlinMachineCUDA-0.2.3 → PyHierarchicalTsetlinMachineCUDA-0.2.6}/setup.py

@@ -2,7 +2,7 @@ from setuptools import *
 
 setup(
    name='PyHierarchicalTsetlinMachineCUDA',
-   version='0.2.3',
+   version='0.2.6',
    author='Ole-Christoffer Granmo',
    author_email='ole.granmo@uia.no',
    url='https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/',
@@ -16,6 +16,7 @@ setup(
 		'pycuda',
 		'scipy',
 		'scikit-learn',
+      'scikit-image',
 		'networkx',
 	],
 	extras_require={