def train(self, input_train, target_train, input_test=None, target_test=None, epochs=100, epsilon=None, summary_type='table'): is_test_data_partialy_missed = ( (input_test is None and target_test is not None) or (input_test is not None and target_test is None) ) if is_test_data_partialy_missed: raise ValueError("Input and target test samples missed. " "They must be defined both or none of them.") input_train = format_data(input_train) target_train = format_data(target_train) if input_test is not None: input_test = format_data(input_test) if target_test is not None: target_test = format_data(target_test) return super(SupervisedLearning, self).train( input_train=input_train, target_train=target_train, input_test=input_test, target_test=target_test, epochs=epochs, epsilon=epsilon, summary_type=summary_type )
def train(self, input_train, target_train, copy=True): """ Trains network. PNN doesn't actually train, it just stores input data and use it for prediction. Parameters ---------- input_train : array-like (n_samples, n_features) target_train : array-like (n_samples,) Target variable should be vector or matrix with one feature column. copy : bool If value equal to ``True`` than input matrices will be copied. Defaults to ``True``. Raises ------ ValueError In case if something is wrong with input data. """ input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy) n_target_features = target_train.shape[1] if n_target_features != 1: raise ValueError("Target value must be one dimensional array") LazyLearningMixin.train(self, input_train, target_train)
def wrapper(actual, expected, *args, **kwargs): actual = format_data(actual) expected = format_data(expected) output = function(actual, expected, *args, **kwargs) # use .item(0) to get a first array element and automaticaly # convert vector that contains one element to scalar return output.eval().item(0)
def train(self, input_train, target_train, copy=True): input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy) if target_train.shape[1] != 1: raise ValueError("Target value must be one dimentional array") LazyLearning.train(self, input_train, target_train)
def _preformat_inputs(actual, predicted): actual = format_data(actual) predicted = format_data(predicted) if actual.shape != predicted.shape: raise ValueError("Actual and predicted values have different shapes. " "Actual shape {}, predicted shape {}" "".format(actual.shape, predicted.shape)) return actual, predicted
def prediction_error(self, input_data, target_data=None): """ Compute the pseudo-likelihood of input samples. Parameters ---------- input_data : array-like Values of the visible layer Returns ------- float Value of the pseudo-likelihood. """ is_input_feature1d = (self.n_visible == 1) input_data = format_data(input_data, is_input_feature1d) errors = self.apply_batches( function=self.methods.prediction_error, input_data=input_data, description='Validation batches', show_error_output=True, ) return average_batch_errors( errors, n_samples=len(input_data), batch_size=self.batch_size, )
def hidden_to_visible(self, hidden_input): """ Propagates output from the hidden layer backward to the visible. Parameters ---------- hidden_input : array-like (n_samples, n_hidden_features) Returns ------- array-like """ is_input_feature1d = (self.n_hidden == 1) hidden_input = format_data(hidden_input, is_input_feature1d) outputs = self.apply_batches( function=self.methods.hidden_to_visible, input_data=hidden_input, description='Visible from hidden batches', show_progressbar=True, show_error_output=False, ) return np.concatenate(outputs, axis=0)
def visible_to_hidden(self, visible_input): """ Populates data throught the network and returns output from the hidden layer. Parameters ---------- visible_input : array-like (n_samples, n_visible_features) Returns ------- array-like """ is_input_feature1d = (self.n_visible == 1) visible_input = format_data(visible_input, is_input_feature1d) outputs = self.apply_batches( function=self.methods.visible_to_hidden, input_data=visible_input, description='Hidden from visible batches', show_progressbar=True, show_error_output=False, ) return np.concatenate(outputs, axis=0)
def predict(self, input_data): """ Make a prediction from the input data. Parameters ---------- input_data : array-like (n_samples, n_features) Raises ------ ValueError In case if something is wrong with input data. Returns ------- array-like (n_samples,) """ super(GRNN, self).predict(input_data) input_data = format_data(input_data) input_data_size = input_data.shape[1] train_data_size = self.input_train.shape[1] if input_data_size != train_data_size: raise ValueError("Input data must contains {0} features, got " "{1}".format(train_data_size, input_data_size)) ratios = pdf_between_data(self.input_train, input_data, self.std) return (dot(self.target_train.T, ratios) / ratios.sum(axis=0)).T
def predict_proba(self, input_data): """ Predict probabilities for each class. Parameters ---------- input_data : array-like (n_samples, n_features) Returns ------- array-like (n_samples, n_classes) """ outputs = self.apply_batches( function=self.predict_raw, input_data=format_data(input_data), description='Prediction batches', show_progressbar=True, show_error_output=False, scalar_output=False, ) raw_output = np.concatenate(outputs, axis=1) total_output_sum = raw_output.sum(axis=0).reshape((-1, 1)) return raw_output.T / total_output_sum
def train(self, input_data, target_data, epochs=100): target_data = format_data(target_data, is_feature1d=True) output_size = target_data.shape[1] if output_size != 1: raise ValueError("Target data must contains only 1 column, got " "{0}".format(output_size)) input_size = input_data.shape[1] gating_network = self.gating_network input_layer = gating_network.connection.input_layers[0] gating_network_input_size = input_layer.size if gating_network_input_size != input_size: raise ValueError( "Gating Network expected get {0} input features, got " "{1}".format(gating_network_input_size, input_size)) networks = self.networks for epoch in range(epochs): predictions = [] for i, network in enumerate(networks): predictions.append(network.predict(input_data)) network.train_epoch(input_data, target_data) predictions = np.concatenate(predictions, axis=1) gating_network.train_epoch(input_data, predictions)
def predict_raw(self, input_data): input_data = format_data(input_data) output = np.zeros((input_data.shape[0], self.n_outputs)) for i, input_row in enumerate(input_data): output[i, :] = self.transform(input_row.reshape(1, -1), self.weight) return output
def train(self, input_data): self.discrete_validation(input_data) input_data = bin2sign(input_data) input_data = format_data(input_data, is_feature1d=False) n_rows, n_features = input_data.shape n_rows_after_update = self.n_memorized_samples + n_rows if self.check_limit: memory_limit = math.ceil(n_features / (2 * math.log(n_features))) if n_rows_after_update > memory_limit: raise ValueError("You can't memorize more than {0} " "samples".format(memory_limit)) weight_shape = (n_features, n_features) if self.weight is None: self.weight = np.zeros(weight_shape, dtype=int) if self.weight.shape != weight_shape: n_features_expected = self.weight.shape[1] raise ValueError("Input data has invalid number of features. " "Got {} features instead of {}." "".format(n_features, n_features_expected)) self.weight = input_data.T.dot(input_data) np.fill_diagonal(self.weight, np.zeros(len(self.weight))) self.n_memorized_samples = n_rows_after_update
def gibbs_sampling(self, visible_input, n_iter=1): """ Makes Gibbs sampling n times using visible input. Parameters ---------- visible_input : 1d or 2d array n_iter : int Number of Gibbs sampling iterations. Defaults to ``1``. Returns ------- array-like Output from the visible units after perfoming n Gibbs samples. Array will contain only binary units (0 and 1). """ is_input_feature1d = (self.n_visible == 1) visible_input = format_data(visible_input, is_input_feature1d) gibbs_sampling = self.methods.gibbs_sampling input_ = visible_input for iteration in range(n_iter): input_ = gibbs_sampling(input_) return input_
def train(self, input_data, target_data, epochs=100): target_data = format_data(target_data, is_feature1d=True) output_size = target_data.shape[1] if output_size != 1: raise ValueError("Target data must contains only 1 column, got " "{0}".format(output_size)) input_size = input_data.shape[1] gating_network = self.gating_network gating_network_input_size = gating_network.input_layer.size if gating_network_input_size != input_size: raise ValueError( "Gating Network expected get {0} input features, got " "{1}".format(gating_network_input_size, input_size) ) networks = self.networks for epoch in range(epochs): predictions = [] for i, network in enumerate(networks): predictions.append(network.predict(input_data)) network.train_epoch(input_data, target_data) predictions = np.concatenate(predictions, axis=1) gating_network.train_epoch(input_data, predictions)
def predict(self, input_data): """ Make a prediction from the input data. Parameters ---------- input_data : array-like (n_samples, n_features) Raises ------ ValueError In case if something is wrong with input data. Returns ------- array-like (n_samples,) """ if self.input_train is None: raise NotTrained("Cannot make a prediction. Network " "hasn't been trained yet") input_data = format_data(input_data) input_data_size = input_data.shape[1] train_data_size = self.input_train.shape[1] if input_data_size != train_data_size: raise ValueError( "Input data must contain {0} features, got " "{1}".format(train_data_size, input_data_size) ) ratios = pdf_between_data(self.input_train, input_data, self.std) return (dot(self.target_train.T, ratios) / ratios.sum(axis=0)).T
def train(self, input_data): self.discrete_validation(input_data) input_data = bin2sign(input_data) input_data = format_data(input_data, is_feature1d=False) nrows, n_features = input_data.shape nrows_after_update = self.n_remembered_data + nrows if self.check_limit: memory_limit = ceil(n_features / (2 * log(n_features))) if nrows_after_update > memory_limit: raise ValueError("You can't memorize more than {0} " "samples".format(memory_limit)) weight_shape = (n_features, n_features) if self.weight is None: self.weight = zeros(weight_shape, dtype=int) if self.weight.shape != weight_shape: raise ValueError("Invalid input shapes. Number of input " "features must be equal to {} and {} output " "features".format(*weight_shape)) self.weight = input_data.T.dot(input_data) fill_diagonal(self.weight, zeros(len(self.weight))) self.n_remembered_data = nrows_after_update
def gibbs_sampling(self, visible_input, n_iter=1): """ Makes Gibbs sampling n times using visible input. Parameters ---------- visible_input : 1d or 2d array n_iter : int Number of Gibbs sampling iterations. Defaults to ``1``. Returns ------- array-like Output from the visible units after perfoming n Gibbs samples. Array will contain only binary units (0 and 1). """ is_input_feature1d = (self.n_visible == 1) visible_input = format_data(visible_input, is_input_feature1d) input_ = visible_input for iteration in range(n_iter): input_ = self.gibbs_sampling_one_step(input_) return input_
def predict(self, input_data): row1d = is_row1d(self.input_layer) result = format_data(input_data, row1d=row1d) for layer in self.layers: result = layer.output(result) return result
def energy(self, input_data, output_data): self.discrete_validation(input_data) self.discrete_validation(output_data) input_data, output_data = bin2sign(input_data), bin2sign(output_data) input_data = format_data(input_data, is_feature1d=False) output_data = format_data(output_data, is_feature1d=False) nrows, n_features = input_data.shape if nrows == 1: return hopfield_energy(self.weight, input_data, output_data) output = np.zeros(nrows) for i, rows in enumerate(zip(input_data, output_data)): output[i] = hopfield_energy(self.weight, *rows) return output
def train(self, input_train, epochs=100, epsilon=None): input_train = format_data(input_train, is_feature1d=True) return super(UnsupervisedLearning, self).train(input_train=input_train, target_train=None, input_test=None, target_test=None, epochs=epochs, epsilon=epsilon)
def energy(self, X_bin, y_bin): self.discrete_validation(X_bin) self.discrete_validation(y_bin) X_sign, y_sign = bin2sign(X_bin), bin2sign(y_bin) X_sign = format_data(X_sign, is_feature1d=False) y_sign = format_data(y_sign, is_feature1d=False) nrows, n_features = X_sign.shape if nrows == 1: return hopfield_energy(self.weight, X_sign, y_sign) output = np.zeros(nrows) for i, rows in enumerate(zip(X_sign, y_sign)): output[i] = hopfield_energy(self.weight, *rows) return output
def energy(self, input_data, output_data): self.discrete_validation(input_data) self.discrete_validation(output_data) input_data, output_data = bin2sign(input_data), bin2sign(output_data) input_data = format_data(input_data, row1d=True) output_data = format_data(output_data, row1d=True) nrows, n_features = input_data.shape if nrows == 1: return hopfield_energy(self.weight, input_data, output_data) output = zeros(nrows) for i, rows in enumerate(zip(input_data, output_data)): output[i] = hopfield_energy(self.weight, *rows) return output
def train(self, input_train, epochs=100): input_train = format_data(input_train, is_feature1d=True) return super(BaseAssociative, self).train( input_train=input_train, target_train=None, input_test=None, target_test=None, epochs=epochs, epsilon=None, summary='table' )
def train(self, input_train, target_train, copy=True): """ Trains network. PNN doesn't actually train, it just stores input data and use it for prediction. Parameters ---------- input_train : array-like (n_samples, n_features) target_train : array-like (n_samples,) Target variable should be vector or matrix with one feature column. copy : bool If value equal to ``True`` than input matrices will be copied. Defaults to ``True``. Raises ------ ValueError In case if something is wrong with input data. """ input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy, make_float=False) LazyLearningMixin.train(self, input_train, target_train) n_target_features = target_train.shape[1] if n_target_features != 1: raise ValueError("Target value should be a vector or a " "matrix with one column") classes = self.classes = np.unique(target_train) n_classes = classes.size n_samples = input_train.shape[0] class_ratios = self.class_ratios = np.zeros(n_classes) row_comb_matrix = self.row_comb_matrix = np.zeros( (n_classes, n_samples)) for i, class_name in enumerate(classes): class_name = classes[i] class_val_positions = (target_train == class_name) row_comb_matrix[i, class_val_positions.ravel()] = 1 class_ratios[i] = np.sum(class_val_positions)
def train(self, input_train, target_train, copy=True): """ Trains network. PNN doesn't actually train, it just stores input data and use it for prediction. Parameters ---------- input_train : array-like (n_samples, n_features) target_train : array-like (n_samples,) Target variable should be vector or matrix with one feature column. copy : bool If value equal to ``True`` than input matrices will be copied. Defaults to ``True``. Raises ------ ValueError In case if something is wrong with input data. """ input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy) LazyLearningMixin.train(self, input_train, target_train) n_target_features = target_train.shape[1] if n_target_features != 1: raise ValueError("Target value should be a vector or a " "matrix with one column") classes = self.classes = np.unique(target_train) n_classes = classes.size n_samples = input_train.shape[0] row_comb_matrix = self.row_comb_matrix = np.zeros( (n_classes, n_samples) ) class_ratios = self.class_ratios = np.zeros(n_classes) for i, class_name in enumerate(classes): class_val_positions = (target_train == i) row_comb_matrix[i, class_val_positions.ravel()] = 1 class_ratios[i] = np.sum(class_val_positions)
def test_format_data(self): # None input self.assertEqual(format_data(None), None) # Sparse data sparse_matrix = csr_matrix((3, 4), dtype=np.int8) formated_sparce_matrix = format_data(sparse_matrix) self.assertIs(formated_sparce_matrix, sparse_matrix) self.assertEqual(formated_sparce_matrix.dtype, sparse_matrix.dtype) # Vector input x = np.random.random(10) formated_x = format_data(x, is_feature1d=True) self.assertEqual(formated_x.shape, (10, 1)) x = np.random.random(10) formated_x = format_data(x, is_feature1d=False) self.assertEqual(formated_x.shape, (1, 10))
def test_format_data(self): # None input self.assertEqual(format_data(None), None) # Sparse data sparse_matrix = csr_matrix((3, 4), dtype=np.int8) formated_sparce_matrix = format_data(sparse_matrix) np.testing.assert_array_equal(formated_sparce_matrix, sparse_matrix) self.assertEqual(formated_sparce_matrix.dtype, sparse_matrix.dtype) # Vector input x = np.random.random(10) formated_x = format_data(x, is_feature1d=True) self.assertEqual(formated_x.shape, (10, 1)) x = np.random.random(10) formated_x = format_data(x, is_feature1d=False) self.assertEqual(formated_x.shape, (1, 10))
def train(self, input_train, epochs=100): input_train = format_data(input_train, is_feature1d=True) return super(BaseAssociative, self).train(input_train=input_train, target_train=None, input_test=None, target_test=None, epochs=epochs, epsilon=None, summary='table')
def raw_predict(self, input_data): input_data = format_data(input_data) input_layer = self.input_layer input_data = input_layer.preformat_input(input_data) self.input_data = input_data self.summated = input_layer.summator(input_data) return input_layer.activation_function(self.summated)
def train(self, input_train, target_train, copy=True): input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy) LazyLearning.train(self, input_train, target_train) if target_train.shape[1] != 1: raise ValueError("Target value must be in 1 dimention") classes = self.classes = unique(target_train) number_of_classes = classes.size row_comb_matrix = self.row_comb_matrix = zeros( (number_of_classes, input_train.shape[0])) class_ratios = self.class_ratios = zeros(number_of_classes) for i, class_name in enumerate(classes): class_val_positions = (target_train == i) row_comb_matrix[i, class_val_positions.ravel()] = 1 class_ratios[i] = np_sum(class_val_positions)
def predict(self, input_data): input_data = format_data(input_data) centers = self.centers classes = zeros((input_data.shape[0], 1)) for i, value in enumerate(input_data): classes[i] = argmin(norm(centers - value, axis=1)) return classes
def train(self, input_train, epsilon=1e-5): n_clusters = self.n_clusters input_train = format_data(input_train) if input_train.shape[0] <= n_clusters: raise ValueError("Count of clusters must be less than count of " "input data.") self.centers = input_train[:n_clusters, :].copy() super(RBFKMeans, self).train(input_train, epsilon=epsilon)
def train(self, input_train, epochs=100, epsilon=None, summary_type='table'): input_train = format_data(input_train, is_feature1d=True) return super(UnsupervisedLearning, self).train( input_train=input_train, target_train=None, input_test=None, target_test=None, epochs=epochs, epsilon=epsilon, summary_type=summary_type )
def format_target(self, y): output_shape = tf.TensorShape(self.network.output_shape) is_feature1d = (output_shape.ndims == 2 and output_shape[1] == 1) formatted_target = format_data(y, is_feature1d=is_feature1d) if (formatted_target.ndim + 1) == len(output_shape): # We assume that when one dimension was missed than user # wants to propagate single sample through the network formatted_target = np.expand_dims(formatted_target, axis=0) return formatted_target
def reconstruct(self, input_data): if self.weights is None: raise ValueError("Train network before use reconstruct method.") input_data = format_data(input_data) if input_data.shape[1] != self.minimized_data_size: raise ValueError("Invalid input data feature space, expected " "{}, got {}.".format(input_data.shape[1], self.minimized_data_size)) return dot(input_data, self.weights.T)
def train(self, input_data, output_data): self.discrete_validation(input_data) self.discrete_validation(output_data) output_data = bin2sign(format_data(output_data, is_feature1d=False)) input_data = bin2sign(format_data(input_data, is_feature1d=False)) _, wight_nrows = input_data.shape _, wight_ncols = output_data.shape weight_shape = (wight_nrows, wight_ncols) if self.weight is None: self.weight = np.zeros(weight_shape) if self.weight.shape != weight_shape: raise ValueError("Invalid input shapes. Number of input " "features must be equal to {} and {} output " "features".format(wight_nrows, wight_ncols)) self.weight += input_data.T.dot(output_data)
def train(self, input_data): self.discrete_validation(input_data) input_data = bin2sign(input_data) #print(input_data.shape) input_data = format_data(input_data, is_feature1d=False) n_rows, n_features = input_data.shape n_rows_after_update = self.n_memorized_samples + n_rows if self.check_limit: memory_limit = math.ceil(n_features / (2 * math.log(n_features))) if n_rows_after_update > memory_limit: raise ValueError("You can't memorize more than {0} " "samples".format(memory_limit)) weight_shape = (n_features, n_features) #print('Weight Shape: ' , weight_shape) if self.weight is None: self.weight = np.zeros(weight_shape, dtype=int) if self.weight.shape != weight_shape: n_features_expected = self.weight.shape[1] raise ValueError("Input data has invalid number of features. " "Got {} features instead of {}." "".format(n_features, n_features_expected)) if self.rule == 'oja': print('Training based on Oja!') self.weight = 0.02 * input_data.T.dot(input_data) coeff = linalg.norm(self.weight, 2) self.weight = self.weight / n_features np.fill_diagonal(self.weight, np.zeros(len(self.weight))) u = 0.01 V = np.dot(self.weight, input_data.T) i = 0 for inp in input_data: v = V[:, i].reshape((n_features, 1)) self.weight += (inp * v) - u * np.square(v) * self.weight i += 1 else: print('Training based on Hebb!') self.weight = 0.02 * input_data.T.dot(input_data) self.weight = self.weight / n_rows #self.weight = self.weight + np.outer(input_data , input_data) np.fill_diagonal(self.weight, np.zeros(len(self.weight))) print(self.weight) self.n_memorized_samples = n_rows_after_update
def train(self, input_train, target_train, copy=True): input_train = format_data(input_train, copy=copy) target_train = format_data(target_train, copy=copy) LazyLearning.train(self, input_train, target_train) if target_train.shape[1] != 1: raise ValueError("Target value must be in 1 dimention") classes = self.classes = unique(target_train) number_of_classes = classes.size row_comb_matrix = self.row_comb_matrix = zeros( (number_of_classes, input_train.shape[0]) ) class_ratios = self.class_ratios = zeros(number_of_classes) for i, class_name in enumerate(classes): class_val_positions = (target_train == i) row_comb_matrix[i, class_val_positions.ravel()] = 1 class_ratios[i] = np_sum(class_val_positions)
def train(self, input_train, input_test=None, epochs=100, epsilon=None, summary_type='table'): input_train = format_data(input_train, is_feature1d=True) if input_test is not None: input_test = format_data(input_test) return super(UnsupervisedLearningMixin, self).train(input_train=input_train, target_train=None, input_test=input_test, target_test=None, epochs=epochs, epsilon=epsilon, summary_type=summary_type)
def reconstruct(self, X): if not isinstance(self.weight, np.ndarray): raise NotTrained("Network hasn't been trained yet") X = format_data(X) if X.shape[1] != self.minimized_data_size: raise ValueError("Invalid input data feature space, expected " "{}, got {}.".format(X.shape[1], self.minimized_data_size)) return np.dot(X, self.weight.T)
def train(self, input_data, output_data): self.discrete_validation(input_data) self.discrete_validation(output_data) output_data = bin2sign(format_data(output_data, row1d=True)) input_data = bin2sign(format_data(input_data, row1d=True)) _, wight_nrows = input_data.shape _, wight_ncols = output_data.shape weight_shape = (wight_nrows, wight_ncols) if self.weight is None: self.weight = zeros(weight_shape) if self.weight.shape != weight_shape: raise ValueError("Invalid input shapes. Number of input " "features must be equal to {} and {} output " "features".format(wight_nrows, wight_ncols)) self.weight += input_data.T.dot(output_data)
def train(self, X_bin, y_bin): self.discrete_validation(X_bin) self.discrete_validation(y_bin) X_sign = bin2sign(format_data(X_bin, is_feature1d=False)) y_sign = bin2sign(format_data(y_bin, is_feature1d=False)) _, weight_nrows = X_sign.shape _, weight_ncols = y_sign.shape weight_shape = (weight_nrows, weight_ncols) if self.weight is None: self.weight = np.zeros(weight_shape) if self.weight.shape != weight_shape: raise ValueError( "Invalid input shapes. Number of input " "features must be equal to {} and {} output " "features".format(weight_nrows, weight_ncols)) self.weight += X_sign.T.dot(y_sign)
def train_epoch(self, input_train, target_train): input_train = format_data(input_train) weight = self.input_layer.weight unconditioned = self.n_unconditioned predict = self.predict weight_delta = self.weight_delta for input_row in input_train: input_row = reshape(input_row, (1, input_row.size)) layer_output = predict(input_row) weight[unconditioned:, :] += weight_delta(input_row, layer_output)
def train(self, X_train, y_train, X_test=None, y_test=None, epochs=100): is_test_data_partialy_missed = ((X_test is None and y_test is not None) or (X_test is not None and y_test is None)) if is_test_data_partialy_missed: raise ValueError("Input and target test samples are missed. " "They must be defined together or none of them.") X_train = format_data(X_train) y_train = format_data(y_train) if X_test is not None: X_test = format_data(X_test) y_test = format_data(y_test) return super(CMAC, self).train(X_train, y_train, X_test, y_test, epochs=epochs)
def format_input_data(self, X): X = format_data(X, is_feature1d=(self.n_inputs == 1)) if X.ndim != 2: raise ValueError("Cannot make prediction, because input " "data has more than 2 dimensions") if X.shape[1] != self.n_inputs: raise ValueError("Input data expected to have {} features, " "but got {}".format(self.n_inputs, X.shape[1])) return X
def predict(self, input_data): input_data = format_data(input_data) get_memory_coords = self.get_memory_coords get_result_by_coords = self.get_result_by_coords predicted = [] for input_sample in self.quantize(input_data): coords = get_memory_coords(input_sample) predicted.append(get_result_by_coords(coords)) return array(predicted)
def predict(self, X): X = format_data(X) get_memory_coords = self.get_memory_coords get_result_by_coords = self.get_result_by_coords predicted = [] for input_sample in self.quantize(X): coords = get_memory_coords(input_sample) predicted.append(get_result_by_coords(coords)) return np.array(predicted)
def energy(self, input_data): self.discrete_validation(input_data) input_data = bin2sign(input_data) input_data = format_data(input_data, is_feature1d=False) nrows, n_features = input_data.shape if nrows == 1: return hopfield_energy(self.weight, input_data, input_data) output = zeros(nrows) for i, row in enumerate(input_data): output[i] = hopfield_energy(self.weight, row, row) return output
def reconstruct(self, input_data): if self.weights is None: raise ValueError("Train network before use reconstruct method.") input_data = format_data(input_data) if input_data.shape[1] != self.minimized_data_size: raise ValueError( "Invalid input data feature space, expected " "{}, got {}.".format( input_data.shape[1], self.minimized_data_size ) ) return dot(input_data, self.weights.T)
def train(self, input_train, epsilon=1e-5, epochs=100): n_clusters = self.n_clusters input_train = format_data(input_train) n_samples = input_train.shape[0] if n_samples <= n_clusters: raise ValueError("Number of samples in the dataset is less than " "spcified number of clusters. Got {} samples, " "expected at least {} (for {} clusters)" "".format(n_samples, n_clusters + 1, n_clusters)) self.centers = input_train[:n_clusters, :].copy() super(RBFKMeans, self).train(input_train, epsilon=epsilon, epochs=epochs)