PyHierarchicalTsetlinMachineCUDA 0.2.5__tar.gz → 0.2.7__tar.gz

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/PyHierarchicalTsetlinMachineCUDA/kernels.py

@@ -159,7 +159,7 @@ code_update = """
 		}
 
 		// Evaluate example
-		__global__ void evaluate_leaves(unsigned int *global_ta_state, int *component_weights, int *global_component_output, int depth, int *hierarchy_structure_factors, int *hierarchy_structure_alternatives, int *X, int example)
+		__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;
@@ -168,35 +168,43 @@ code_update = """
 
 			// 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;
 				}
 
@@ -213,9 +221,15 @@ code_update = """
 			for (int or_group_node = index; or_group_node < CLAUSES*number_of_or_group_nodes; or_group_node += stride) {
 				// Add OR addends
 				int or_group_vote_sum = 0;
+				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
 
+					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) {
@@ -224,8 +238,8 @@ code_update = """
 					}
 				}
 
-				// 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;
 			}
 		}
 
@@ -238,12 +252,17 @@ code_update = """
 			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;
@@ -252,6 +271,7 @@ code_update = """
 
 				// 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;
 			}
 		}
 
@@ -272,6 +292,58 @@ code_update = """
 			}
 		}
 
+		__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;
@@ -316,7 +388,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, 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 +400,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 +441,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);
 				}
 			}
 		
@@ -503,7 +589,7 @@ code_clauses = """
 		int index = blockIdx.x * blockDim.x + threadIdx.x;
 		int stride = blockDim.x * gridDim.x;
 
-		for (unsigned long long i = index; i < CLAUSES * COMPONENTS * LITERALS_PER_LEAF; i += stride) {
+		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;
 			unsigned long long ta_idx = i % LITERALS_PER_LEAF;

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/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,
@@ -517,10 +539,16 @@ class CommonTsetlinMachine():
 				left = []
 				right = []
 				inside = []
+				feature_base = 0
+				size = self.hierarchy_structure[0][1]
 				for d in range(1, self.depth):
 					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:
+						feature_base += size * depth_d_node_index 
+						size *= self.hierarchy_structure[d][1];
+
 					if previous_index[d-1] == -1:
 						left.append("(")
 					elif depth_d_node_index == 0 and previous_index[d-1] != depth_d_node_index:
@@ -545,14 +573,14 @@ class CommonTsetlinMachine():
 					if self.ta_action(i, j, k):
 						if k < self.number_of_literals_per_leaf // 2:
 							if print_ta_state:
-								l.append("x%d(%d)" % (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" % (k,))
+								l.append("x%d" % (feature_base + k,))
 						else:
 							if print_ta_state:
-								l.append("¬x%d(%d)" % (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" % (k - self.number_of_literals_per_leaf // 2,))
+								l.append("¬x%d" % (feature_base + k - self.number_of_literals_per_leaf // 2,))
 				
 				if len(l) > 1:
 					print("(" + " ∧ ".join(l) + ")", end = '')

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/PyHierarchicalTsetlinMachineCUDA.egg-info/PKG-INFO

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

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/PyHierarchicalTsetlinMachineCUDA.egg-info/requires.txt

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

{PyHierarchicalTsetlinMachineCUDA-0.2.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/README.md

@@ -1,10 +1,6 @@
 # Hierarchical Tsetlin Machine in CUDA
 Implements the [Hierarchical Tsetlin Machine](https://github.com/cair/HierarchicalTsetlinMachine) in CUDA.
 
-<p align="center">
-  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/main/figures/Visualization_voting.png">
-</p>
-
 ## Installation
 
 ```bash
@@ -15,13 +11,17 @@ or
 git clone git@github.com:cair/PyHierarchicalTsetlinMachineCUDA.git
 cd PyHierarchicalTsetlinMachineCUDA
 python ./setup.py sdist
-pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.2.tar.gz 
+pip install dist/PyHierarchicalTsetlinMachineCUDA-0.2.6.tar.gz 
 ```
 
 ## Examples
 
 ### Noisy Parity Demo
 
+<p align="center">
+  <img width="60%" src="https://github.com/cair/PyHierarchicalTsetlinMachineCUDA/blob/main/figures/Visualization_voting.png">
+</p>
+
 #### Code: NoisyParityDemo.py
 
 ```python
@@ -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.5 → PyHierarchicalTsetlinMachineCUDA-0.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import *
 
 setup(
    name='PyHierarchicalTsetlinMachineCUDA',
-   version='0.2.5',
+   version='0.2.7',
    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={