def hash_from_pattern(m, base=2): """ Calculate for a spike pattern or a matrix of spike patterns (provide each pattern as a column) composed of N neurons a unique number. Parameters ---------- m: np.ndarray or list 2-dim ndarray spike patterns represented as a binary matrix (i.e., matrix of 0's and 1's). Rows and columns correspond to patterns and neurons, respectively. base: integer The base for hashes calculation. Default: 2 Returns ------- np.ndarray An array containing the hash values of each pattern, shape: (number of patterns). Raises ------ ValueError If matrix `m` has wrong orientation. Examples -------- With `base=2`, the hash of `[0, 1, 1]` is `0*2^2 + 1*2^1 + 1*2^0 = 3`. >>> import numpy as np >>> hash_from_pattern([0, 1, 1]) 3 >>> import numpy as np >>> m = np.array([[0, 1, 0, 0, 1, 1, 0, 1], ... [0, 0, 1, 0, 1, 0, 1, 1], ... [0, 0, 0, 1, 0, 1, 1, 1]]) >>> hash_from_pattern(m) array([0, 4, 2, 1, 6, 5, 3, 7]) """ m = np.asarray(m) n_neurons = m.shape[0] # check the entries of the matrix if not is_binary(m): raise ValueError('Patterns should be binary: 0 or 1') # generate the representation # don't use numpy - it's upperbounded by int64 powers = [base ** x for x in range(n_neurons)][::-1] # calculate the binary number by use of scalar product return np.dot(powers, m)
def is_binary(self): """ Checks and returns **True** if given input is a binary input. Beware, that the function does not know if the input is binary because e.g `to_bool_array()` was used before or if the input is just sparse (i.e. only one spike per bin at maximum). """ return is_binary(self.lst_input)
def n_emp_mat(mat, pattern_hash, base=2): """ Count the occurrences of spike coincidence patterns in the given spike trains. Parameters ---------- mat : (N, M) np.ndarray Binned spike trains of N neurons. Rows and columns correspond to neurons and temporal bins, respectively. pattern_hash: list of int List of hash values, representing the spike coincidence patterns of which occurrences are counted. base: integer The base, used to generate the hash values. Default: 2 Returns ------- N_emp: np.ndarray The number of occurrences of the given patterns in the given spiketrains. indices: list of list List of lists of int. Indices indexing the bins where the given spike patterns are found in `mat`. Same length as `pattern_hash`. `indices[i] = N_emp[i] = pattern_hash[i]` Raises ------ ValueError If `mat` is not a binary matrix. Examples -------- >>> mat = np.array([[1, 0, 0, 1, 1], ... [1, 0, 0, 1, 0]]) >>> pattern_hash = np.array([1,3]) >>> n_emp, n_emp_indices = n_emp_mat(mat, pattern_hash) >>> print(n_emp) [ 0. 2.] >>> print(n_emp_indices) [array([]), array([0, 3])] """ # check if the mat is zero-one matrix if not is_binary(mat): raise ValueError("entries of mat should be either one or zero") h = hash_from_pattern(mat, base=base) N_emp = np.zeros(len(pattern_hash)) indices = [] for idx_ph, ph in enumerate(pattern_hash): indices_tmp = np.where(h == ph)[0] indices.append(indices_tmp) N_emp[idx_ph] = len(indices_tmp) return N_emp, indices
def is_binary(self): """ Returns True if the sparse matrix contains binary values only. Beware, that the function does not know if the input was binary because e.g `to_bool_array()` was used before or if the input is just sparse (i.e. only one spike per bin at maximum). Returns ------- bool True for binary input, False otherwise. """ return is_binary(self.sparse_matrix.data)
def is_binary(self): """ Checks and returns `True` if given input is a binary input. Beware, that the function does not know if the input is binary because e.g `to_bool_array()` was used before or if the input is just sparse (i.e. only one spike per bin at maximum). Returns ------- bool True for binary input, False otherwise. """ return is_binary(self.sparse_matrix.data)
def n_emp_mat_sum_trial(mat, pattern_hash): """ Calculates empirical number of observed patterns summed across trials Parameters ----------- mat: np.ndarray 3d numpy array or elephant BinnedSpikeTrain object Binned spike trains represented as a binary matrix (i.e., matrix of 0's and 1's), segmented into trials. Trials should contain an identical number of neurons and an identical number of time bins. the entries are zero or one 0-axis --> trials 1-axis --> neurons 2-axis --> time bins pattern_hash: list Array of hash values, length: number of patterns. Returns -------- N_emp: np.ndarray numbers of occurences of the given spike patterns in the given spike trains, summed across trials. Same length as `pattern_hash`. idx_trials: list list of indices of mat for each trial in which the specific pattern has been observed. 0-axis --> trial 1-axis --> list of indices for the chosen trial per entry of `pattern_hash` Raises ------- ValueError: if matrix mat has wrong orientation ValueError: if mat is not zero-one matrix Examples --------- >>> mat = np.array([[[1, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 0, 1]], [[1, 1, 1, 1, 1], [0, 1, 1, 1, 1], [1, 1, 0, 1, 0]]]) >>> pattern_hash = np.array([4,6]) >>> N = 3 >>> n_emp_sum_trial, n_emp_sum_trial_idx = \ >>> n_emp_mat_sum_trial(mat, N,pattern_hash) >>> n_emp_sum_trial array([ 1., 3.]) >>> n_emp_sum_trial_idx [[array([0]), array([3])], [array([], dtype=int64), array([2, 4])]] """ num_patt = len(pattern_hash) N_emp = np.zeros(num_patt) idx_trials = [] # check if the mat is zero-one matrix if not is_binary(mat): raise ValueError("entries of mat should be either one or zero") for mat_tr in mat: N_emp_tmp, indices_tmp = n_emp_mat(mat_tr, pattern_hash, base=2) idx_trials.append(indices_tmp) N_emp += N_emp_tmp return N_emp, idx_trials
def hash_from_pattern(m, base=2): """ Calculate for a spike pattern or a matrix of spike patterns (provide each pattern as a column) composed of N neurons a unique number. Parameters ----------- m: np.ndarray 2-dim ndarray spike patterns represented as a binary matrix (i.e., matrix of 0's and 1's). Rows and columns correspond to patterns and neurons, respectively. base: integer base for calculation of hash values from binary sequences (= pattern). Default is 2 Returns -------- np.ndarray An array containing the hash values of each pattern, shape: (number of patterns). Raises ------- ValueError if matrix `m` has wrong orientation Examples --------- descriptive example: m = [0 1 1] N = 3 base = 2 hash = 0*2^2 + 1*2^1 + 1*2^0 = 3 second example: >>> import numpy as np >>> m = np.array([[0, 1, 0, 0, 1, 1, 0, 1], >>> [0, 0, 1, 0, 1, 0, 1, 1], >>> [0, 0, 0, 1, 0, 1, 1, 1]]) >>> hash_from_pattern(m) array([0, 4, 2, 1, 6, 5, 3, 7]) """ n_neurons = m.shape[0] # check the entries of the matrix if not is_binary(m): raise ValueError('Patterns should be binary: 0 or 1') # generate the representation # don't use numpy - it's upperbounded by int64 powers = np.array([base**x for x in range(n_neurons)]) powers = sorted(powers, reverse=True) # calculate the binary number by use of scalar product return np.dot(powers, m)