def resample(curr_samples,prob,afnv): dt = numpy.dtype('f8'); nsamples = MA(curr_samples.shape).item(0) if prob.sum() ==0 : map_afnv = MA(numpy.ones(nsamples),dt)*afnv count = MA(numpy.zeros((prob.shape),dt)) else: prob = prob/(prob.sum()) count = MA(numpy.ceil(nsamples*prob),int) count = count.T map_afnv = MA(numpy.zeros((1,6)),dt); for i in range(nsamples): for j in range(count[i]): map_afnv = MA(numpy.concatenate((map_afnv,curr_samples[i,:]),axis=0),dt) K = map_afnv.shape[0]; map_afnv = map_afnv[1:K,:]; ns = count.sum() if nsamples > ns: map_afnv = MA(numpy.concatenate((map_afnv,MA(numpy.ones(((nsamples-ns),1))*afnv,dt)),axis=0),dt) map_afnv = map_afnv[0:nsamples,:] return map_afnv,count
def nipals1(x: np.matrix): max_it = 3 # max_it = matrix_rank(x) # print("rank(x) = " + str(max_it)) p = np.zeros(shape=(x.shape[1], max_it)) t = np.zeros(shape=(x.shape[0], max_it)) for j in range(0, max_it): # a = norm(x, axis=0) # idx = a.argmax() t_j = x[:, j] # # verify if the column is a zero vector # zero_col = np.zeros(shape=t_j.shape) # if norm(t_j - zero_col) <= epsilon: # j += 1 # max_it += 1 # continue t_j1 = t_j - t_j while norm(t_j1 - t_j) > epsilon: p_j = x.transpose().dot(t_j) p_j /= norm(p_j) t_j1 = t_j t_j = x.dot(p_j) p[:, j] = p_j t[:, j] = t_j j += 1 x = x - np.dot(t_j[:, None], p_j[None, :]) return t, p
def eigen(matx: np.matrix, eps=1e-3): """ функція знаходження власного числа і вектора методом скалярних добутків """ tr_matrix = matx.transpose() y = np.zeros(matx.shape[0]) z = np.zeros(matx.shape[0]) y[0] = START_Y z[0] = y[0] eigenvalue = 0 for j in range(ITERATION_LIMIT): if y.shape[0] == 1: y = y.transpose() if z.shape[0] == 1: z = z.transpose() next_y = np.array(matx.dot(y)) next_z = np.array(tr_matrix.dot(z)) tmp1 = sum1(next_y * next_z) tmp2 = sum1(y * next_z) tmp_res = tmp1 / tmp2 if j == 0: eigenvalue = tmp_res elif abs(eigenvalue - tmp_res) < eps: break else: eigenvalue = tmp_res y = next_y z = next_z eigenvector = y / norm(y) return eigenvalue, eigenvector
def dump_dataset(dataset: np.matrix, description: dict) -> None: np.savetxt('caloria_dataset.csv', dataset, delimiter=',') with open('caloria_description.json', 'w') as desc_file: json.dump(description, desc_file) dataset.dump('caloria_xy_matrix.np')
def resample(curr_samples, prob, afnv): dt = numpy.dtype('f8') nsamples = MA(curr_samples.shape).item(0) if prob.sum() == 0: map_afnv = MA(numpy.ones(nsamples), dt) * afnv count = MA(numpy.zeros((prob.shape), dt)) else: prob = prob / (prob.sum()) count = MA(numpy.ceil(nsamples * prob), int) count = count.T map_afnv = MA(numpy.zeros((1, 6)), dt) for i in range(nsamples): for j in range(count[i]): map_afnv = MA( numpy.concatenate((map_afnv, curr_samples[i, :]), axis=0), dt) K = map_afnv.shape[0] map_afnv = map_afnv[1:K, :] ns = count.sum() if nsamples > ns: map_afnv = MA( numpy.concatenate( (map_afnv, MA(numpy.ones( ((nsamples - ns), 1)) * afnv, dt)), axis=0), dt) map_afnv = map_afnv[0:nsamples, :] return map_afnv, count
def _agg_apply(self, matrix: np.matrix, agg: str, axis: int) -> np.ndarray: """ Apply aggregate function onto matrix along specified axis. By default, COO matrices support sum, mean, min, max methods ("built-in"). For other operations("derived"), formula out of built-in methods is used. """ agg_axis = abs(1 - axis) # to aggregate opposite axis if agg in self._SUPPORTED_AGG_FUNCS["built-in"]: agg_func = getattr(matrix, agg) rna_agg_out = agg_func(axis=agg_axis) elif agg in self._SUPPORTED_AGG_FUNCS["derived"]: if agg == "nonzero": rna_agg_out = (matrix > 0).sum(agg_axis) else: # TODO: might run out of memory because there is conversion to numpy matrix in agg funcs rna_var = matrix.power(2).mean(axis=agg_axis) - np.power( matrix.mean(axis=agg_axis), 2) rna_agg_out = np.sqrt( rna_var) if agg == "std" else rna_var # std is sqrt(var) else: raise NotImplementedError( f'aggregation function "{agg}" not supported, valid options are: {self._SUPPORTED_AGG_FUNCS["all"]}' ) rna_agg = np.ravel(rna_agg_out.sum(axis=agg_axis)) # flatten matrix return rna_agg
def affparaminv(est): #!!!pay attention dt = np.dtype('f8') q = MA(np.zeros(2,3),dt) q = linalg.pinv(MA([[est[0,2],est[0,3]],[est[0,4],est[0,5]]])) * MA([[-est[0,0],1.0,0.0],[-est[0,1],0,1.0]]) q=q.flatten(1) return MA([[q[0,0],q[0,1],q[0,2],q[0,4],q[0,3],q[0,5]]])
def floyd_warshall(W: np.matrix, print_k: bool = False): W = np.copy(W) P = create_P(W) n = len(W) print("starting P") print(f"{P=}") for k in range(1, n + 1): for i in range(1, n + 1): for j in range(1, n + 1): current = W.item((i - 1, j - 1)) candidate = W.item((i - 1, k - 1)) + W.item((k - 1, j - 1)) if current > candidate: debug and print( f"Currently doing {i} -> {j} " + f"for a cost of {current} " + f"but we can do better going through {k} " + f"for a cost of {candidate} instead. " f"current value at {P.item((k - 1, j - 1))=}") W.itemset((i - 1, j - 1), candidate) P.itemset((i - 1, j - 1), P.item((k - 1, j - 1))) if print_k: print(f"for {k=}") print(f"{W=}") print(f"{P=}") return W, P
def batch_update(self, x: np.matrix, chosen_arm: int, reward: float) -> None: """Update the information about the arms with a new batch of data. :param x: observed context matrix. :param chosen_arm: index of the chosen arm. :param reward: reward from the chosen arm. """ self.data_size += 1 z = x[:][:self.z_dim] x = x[:][self.z_dim:] self.counts[chosen_arm] += 1 self.rewards += reward self._A_zero += self._B[chosen_arm].T.dot(self._A_inv[chosen_arm]).dot(self._B[chosen_arm]) self._b_zero += self._B[chosen_arm].T.dot(self._A_inv[chosen_arm]).dot(self._b[chosen_arm]) self._A_inv[chosen_arm] -= self._A_inv[chosen_arm].dot(x.dot(x.T.dot(self._A_inv[chosen_arm]))) / (1 + x.T.dot(self._A_inv[chosen_arm].dot(x))) self._B[chosen_arm] += x.dot(z.T) self._b[chosen_arm] += x * reward self._A_zero += z.dot(z.T) - self._B[chosen_arm].T.dot(self._A_inv[chosen_arm]).dot(self._B[chosen_arm]) self._b_zero += z * reward - self._B[chosen_arm].T.dot(self._A_inv[chosen_arm]).dot(self._b[chosen_arm]) if self.data_size % self.batch_size == 0: self.A_zero = self._A_zero[:] self.b_zero = self._b_zero[:] self.A_inv = copy.deepcopy(self._A_inv) self.B = copy.deepcopy(self._B) self.b = copy.deepcopy(self._b)
def find_tfrom_between_shapes(from_shape: np.matrix, to_shape: np.matrix ) -> Tuple[np.matrix]: """ Find transform between shapes Parameters: ---------- :param from_shape: type(numpy.matrix Input shape :param to_shape: type(numpy.matrix Output shape :return: tran_m - transformation matrix, tran_b - transformation matrix """ assert from_shape.shape[0] == to_shape.shape[0] and from_shape.shape[0] % 2 == 0 sigma_from = 0.0 sigma_to = 0.0 cov = np.matrix([[0.0, 0.0], [0.0, 0.0]]) # compute the mean and cov from_shape_points = from_shape.reshape(from_shape.shape[0] // 2, 2) to_shape_points = to_shape.reshape(to_shape.shape[0] // 2, 2) mean_from = from_shape_points.mean(axis=0) mean_to = to_shape_points.mean(axis=0) for i in range(from_shape_points.shape[0]): temp_dis = np.linalg.norm(from_shape_points[i] - mean_from) sigma_from += temp_dis * temp_dis temp_dis = np.linalg.norm(to_shape_points[i] - mean_to) sigma_to += temp_dis * temp_dis cov += (to_shape_points[i].transpose() - mean_to.transpose()) * ( from_shape_points[i] - mean_from ) sigma_from = sigma_from / to_shape_points.shape[0] sigma_to = sigma_to / to_shape_points.shape[0] cov = cov / to_shape_points.shape[0] # compute the affine matrix s = np.matrix([[1.0, 0.0], [0.0, 1.0]]) u, d, vt = np.linalg.svd(cov) if np.linalg.det(cov) < 0: if d[1] < d[0]: s[1, 1] = -1 else: s[0, 0] = -1 r = u * s * vt c = 1.0 if sigma_from != 0: c = 1.0 / sigma_from * np.trace(np.diag(d) * s) tran_b = mean_to.transpose() - c * r * mean_from.transpose() tran_m = c * r return tran_m, tran_b
def precision_calc(resample: np.matrix): """ Calculate precision score from matrix. Assume the first column to be y_true and the second column to be y_pred Args: resample: matrix with 2 columns [y_true, y_pred] Returns: precision score: float """ return precision_score(resample.tolist()[0], resample.tolist()[1])
def multiply_vecmat(vec: vec3d, mat: np.matrix) -> vec3d: if mat.shape[0] == 1: mat=mat.tolist()[0] else: mat=mat.tolist() return vec3d( vec.x*mat[0][0]+vec.y*mat[1][0]+vec.z*mat[2][0]+vec.w*mat[3][0], vec.x*mat[0][1]+vec.y*mat[1][1]+vec.z*mat[2][1]+vec.w*mat[3][1], vec.x*mat[0][2]+vec.y*mat[1][2]+vec.z*mat[2][2]+vec.w*mat[3][2], vec.x*mat[0][3]+vec.y*mat[1][3]+vec.z*mat[2][3]+vec.w*mat[3][3])
def binary(img1, level): img1 = MA(img1) tempIm = img1.flatten(1) for i in range(tempIm.shape[1]): if tempIm[0,i] < level: tempIm[0,i] = 0; else: tempIm[0,i] = 1; tempIm = (numpy.reshape(tempIm,(img1.shape[1],img1.shape[0]))).T return tempIm
def __init__(self, vals: np.matrix): self.shift_factor = np.array(vals.min(1)).astype(float) self.scale_factor = np.array(vals.max(1) - self.shift_factor).astype(float) self.scale_factor = self.scale_factor + (self.scale_factor == 0).astype(float) self.shift_factor = self.shift_factor.reshape( self.shift_factor.shape[0], 1) self.scale_factor = self.scale_factor.reshape( self.scale_factor.shape[0], 1) self.scale_factor = 1.0
def get_matrix_cost(matrix: np.matrix) -> np.matrix: cost_matrix = matrix.copy() minimal_column = matrix.min(1)[:np.newaxis] minimal_column[minimal_column == np.inf] = 0 # Subtract minimal value of a row from matrix cost_matrix -= minimal_column minimal_row = cost_matrix.min(0) minimal_row[minimal_row == np.inf] = 0 # Subtract minimal value of a column from matrix cost_matrix -= minimal_row return cost_matrix
def get_r_squared(model: Linear_Regression, X: np.matrix, y: np.matrix) -> float: nominator: float = 0 denominator: float = 0 y_list: List[List[float]] = y.tolist() y_avg: float = np.average(y_list) for idx, x in enumerate(X.tolist()): nominator += (model.fit(x[:4]) - y_list[idx][0]) ** 2 denominator += (y_avg - y_list[idx][0]) ** 2 return 1 - (nominator/denominator)
def matrix_3d_to_4x4(matrix: np.matrix) -> np.matrix: """Calculates the 3d 4x4 affine transformation matrix from the given 3d 3x3 affine rotation matrix""" return np.matrix( [[matrix.item(0, 0), matrix.item(0, 1), matrix.item(0, 2), 0], [matrix.item(1, 0), matrix.item(1, 1), matrix.item(1, 2), 0], [matrix.item(2, 0), matrix.item(2, 1), matrix.item(2, 2), 0], [0, 0, 0, 1]])
def getStochasticMatrix(inputMatrix: matrix, normZeros: bool = False) -> matrix: columnSums = asarray(inputMatrix.sum(0)).reshape(-1) if normZeros: for i in range(len(columnSums)): columnSum: float = columnSums[i] if columnSum == 0: inputMatrix[:, i] = 1 return inputMatrix / inputMatrix.sum(0) else: columnSums[columnSums == 0] = 1 return inputMatrix / columnSums
def binary(img1, level): img1 = MA(img1) #import pdb;pdb.set_trace() tempIm = img1.flatten(1) for i in range(tempIm.shape[1]): if tempIm[0,i] < level: tempIm[0,i] = 0; else: tempIm[0,i] = 1; tempIm = (numpy.reshape(tempIm,(img1.shape[1],img.shape[0]))).T print tempIm return tempIm
def binary(img1, level): img1 = MA(img1) #import pdb;pdb.set_trace() tempIm = img1.flatten(1) for i in range(tempIm.shape[1]): if tempIm[0, i] < level: tempIm[0, i] = 0 else: tempIm[0, i] = 1 tempIm = (numpy.reshape(tempIm, (img1.shape[1], img.shape[0]))).T print tempIm return tempIm
def matrix_2d_to_3d(matrix: np.matrix) -> np.matrix: """Calculates the 3d affine transformation matrix from the given 2d affine transformation matrix""" return np.matrix( [[matrix.item(0, 0), matrix.item(0, 1), 0, matrix.item(0, 2)], [matrix.item(1, 0), matrix.item(1, 1), 0, matrix.item(1, 2)], [0, 0, 1, 0], [matrix.item(2, 0), matrix.item(2, 1), 0, matrix.item(2, 2)]])
def naive_multiplication(m0: np.matrix, m1: np.matrix): shape_m0 = m0.shape shape_m1 = m1.shape m01 = np.zeros((shape_m0[0], shape_m1[1])) if shape_m0[1] != shape_m1[0]: raise ValueError("Dimensions not aligned : dim0(m0)=" + str(shape_m0[1]) + " and dim1(m1)=" + str(shape_m1[0])) for i in np.arange(shape_m0[0]): for j in np.arange(shape_m1[1]): for k in np.arange(shape_m1[0]): m01[i][j] += m0.item((i, k)) * m1.item((k, j)) return m01
def get_probability_transition_matrix(A: np.matrix): """ Calcule la matrice de probabilité de transition à partir de la matrice d'adjacence :param A: La matrice de base :return: La matrice de probabilités de transition """ res = [] for i in range(A.__len__()): res.append([0] * A.__len__()) do = A.sum(axis=1) for i in range(A.__len__()): res[i] = (A[i] / float(do.item(i))).A1 return np.matrix(res)
def setRotation(cls, m: np.matrix, rotation: list): rmat = quaternion_matrix(rotation) m.itemset(0, 0, rmat.item(0, 0)) m.itemset(0, 1, rmat.item(0, 1)) m.itemset(0, 2, rmat.item(0, 2)) m.itemset(1, 0, rmat.item(1, 0)) m.itemset(1, 1, rmat.item(1, 1)) m.itemset(1, 2, rmat.item(1, 2)) m.itemset(2, 0, rmat.item(2, 0)) m.itemset(2, 1, rmat.item(2, 1)) m.itemset(2, 2, rmat.item(2, 2))
def encryptBlock(data: np.matrix, key: np.matrix) -> np.matrix: encoded = data.getT() ^ key.getT() keys = extendKey(key) for i in range(1, len(keys)): encoded = bytesSub(encoded) # print("{} After subst {}".format(i, encoded.flatten())) encoded = shiftRows(encoded) # print("{} After shift row {}".format(i, encoded.flatten())) if i < len(keys) - 1: encoded = mixColumns(encoded) # print("{} After mix {}".format(i, encoded.flatten())) # print("Applying key {}".format(keys[i].flatten())) encoded = encoded ^ keys[i].getT() # print("{} After RoundKey {}".format(i, encoded.flatten())) return encoded.getT().tobytes()[::8]
def get_chosen_range(grid: numpy.matrix, app: PySide.QtGui.QApplication) -> list: # http://segmentfault.com/q/1010000003028975 size = grid.shape twid = PySide.QtGui.QTableWidget(size[0], size[1]) # 为了设置宽度方便 for col in range(size[1]): twid.setColumnWidth(col, 80) for row in range(size[0]): value = grid.item(row, col) item = PySide.QtGui.QTableWidgetItem(str(value)) twid.setItem(row, col, item) twid.resize(1020, 400) twid.setEditTriggers(PySide.QtGui.QAbstractItemView.NoEditTriggers) twid.show() chosen_cell = [] @PySide.QtCore.Slot(int, int) def double_click_cell(row, col): chosen_cell.append([row, col]) print(chosen_cell) if len(chosen_cell) == 2: app.closeAllWindows() twid.cellDoubleClicked.connect(double_click_cell) app.exec_() return chosen_cell
def funm(dat: numpy.matrix, f) -> numpy.matrix: '''Dirty copycat for scipy.linalg.funm''' ret = dat.copy() for x in numpy.nditer(ret, op_flags=['readwrite']): x[...] = f(x) return ret
def setLocalTransformMatrix(self, m: np.matrix): ''' Sets the local transform matrix of this bone. ''' self.transformMatrix = np.matrix(m.copy()) self.markGlobalTransformDirty()
def hotelling(x: np.matrix): s = x.sum(axis=1) alpha = s / np.amax(s) # print("alpha = " + str(alpha)) alpha_old = alpha - alpha while (np.absolute(alpha - alpha_old)).sum() >= epsilon: # print("============================") beta = x.dot(alpha) # print("beta = " + str(beta)) alpha_old = alpha alpha = beta / np.amax(beta) # print("alpha = " + str(alpha)) # print("difference = " + str(np.absolute(alpha - alpha_old))) # print("diff_sum = " + str((np.absolute(alpha - alpha_old)).sum())) return alpha, np.amax(beta)
def __init__( self, ATAC_data: np.matrix = None, ATAC_name: pd.DataFrame = None, cell_name: pd.DataFrame = None, delayed_populating: bool = False, is_filter=True, datatype="atac_seq", ): if ATAC_data.all() == None: raise Exception( "Invalid Input, the gene expression matrix is empty!") self.ATAC_data = ATAC_data self.ATAC_name = ATAC_name self.cell_name = cell_name self.is_filter = is_filter self.datatype = datatype self.cell_name_formulation = None self.atac_name_formulation = None if not isinstance(self.ATAC_name, pd.DataFrame): self.ATAC_name = pd.DataFrame(self.ATAC_name) if not isinstance(self.cell_name, pd.DataFrame): self.cell_name = pd.DataFrame(self.cell_name) # form data name and filename unless manual override logger.debug("Loading atac expression dataset") super().__init__() if not delayed_populating: self.populate()
def ComputeSVD(A: np.matrix): """Given a matrix A use the eigen value decomposition to compute a SVD decomposition. It returns a tuple (U,Sigma,V) of np.matrix objects.""" k = np.linalg.matrix_rank(A) B = A.transpose() @ A w, V = eig(B) #Eigenwerte und Vektoren neu sortieren idx = np.argsort(w) w = w[idx] V = V[:, idx] #S berechnen S = np.zeros(A.shape) for i in range(S.shape[0]): for j in range(S.shape[1]): if i == j: S[i][j] = sqrt(w[i]) #U berechnen U = np.zeros((k + 1, k + 1)) for i in range(k): U[:, i] = (1 / S[i][i] * A * V[:, i]).flat U = np.linalg.qr(U)[0] return np.asmatrix(U), np.asmatrix(S), np.asmatrix(V)
def next_neighbor(terrain: np.matrix, position: Tuple[int, int]) -> Tuple[int, int]: """ Returns the position of the lowest neighbor. Args: terrain: the terrain's configuration comprised from integer elevation levels. position: the pair of integers representing the ball's current position. Output: The position (pair of coordinates) of the lowest neighbor. Example: >>> next_neighbor(np.matrix([[-2, 3, 2, 1]]), (0, 1)) (0, 0) """ x, y = position allowed_neighbors = [] for delta_x in range(-1, 2): for delta_y in range(-1, 2): new_position = (x + delta_x, y + delta_y) if (not wall(terrain, new_position)): allowed_neighbors.append( (terrain.item(new_position), new_position)) return min(allowed_neighbors)[1]
def svd(m: np.matrix): """ Returns the SVD of a matrix. Parameters ---------- m: np.matrix The matrix to decompose Returns ------- np.matrix or None The first matrix of the decomposition. This is a orthogonal matrix. np.matrix The matrix with the singular values in the diagonal. np.matrix The second matrix of the decomposition. This one is also a orthogonal matrix. """ m = np.float64(m.copy()) _, columns = m.shape svdMatrix = m @ m.T singValues, uMatrix = symmetricEig(svdMatrix) singValues, uMatrix = _sortEig(singValues, uMatrix) singValues = np.sqrt(np.abs(singValues)) vMatrix = m.T @ uMatrix for i in range(vMatrix.shape[1]): vMatrix[i, :] = vMatrix[i, :] / np.linalg.norm(vMatrix[i, :]) return uMatrix, singValues[:columns], vMatrix.T
def decompose(cls, m: np.matrix): t = cls.getTranslation(m) s = cls.getScale(m) norm = np.identity(4) norm.itemset(0, 0, m.item(0, 0) / s[0]) norm.itemset(0, 1, m.item(0, 1) / s[0]) norm.itemset(0, 2, m.item(0, 2) / s[0]) norm.itemset(1, 0, m.item(1, 0) / s[1]) norm.itemset(1, 1, m.item(1, 1) / s[1]) norm.itemset(1, 2, m.item(1, 2) / s[1]) norm.itemset(2, 0, m.item(2, 0) / s[2]) norm.itemset(2, 1, m.item(2, 1) / s[2]) norm.itemset(2, 2, m.item(2, 2) / s[2]) return s, cls.getRotation(norm), t
def __init__(self, left_num_neurons, right_num_neurons, transfer_function): """ Initializes a vectorneuron with a weight matrix of size (left_num_neurons, right_num_neurons), a bias vector of size (right_num_neurons, 1), and a transfer function transfer_function. """ print '>>> Creating VectorNeuron: (%s, %s) %s' % \ (left_num_neurons, right_num_neurons, transfer_function) self.__weight_matrix = Matrix(rand(right_num_neurons, left_num_neurons)) self.__weight_matrix_backup = self.__weight_matrix.copy() self.__bias_vector = Matrix(rand(right_num_neurons, 1)) self.__delta_w_matrix = Matrix(rand(right_num_neurons, left_num_neurons)) self.__mersenne_twister = MersenneTwister() self.__mersenne_twister.seed(int(1000*time.time())) self.__transfer_function = transfer_function
class VectorNeuron(object): """ The VectorNeuron class represents a single weight matrix and a corresponding transfer function. An input to a VectorNeuron is first multiplied by the weight matrix. The result is then fed through a transfer function to produce the VectorNeuron's output. The output is either the containing neural network's final output or the input to another VectorNeuron. """ __weight_matrix = None __weight_matrix_backup = None __bias_vector = None __delta_w_matrix = None __result = None __transfer_function = "" __mersenne_twister = None def __init__(self, left_num_neurons, right_num_neurons, transfer_function): """ Initializes a vectorneuron with a weight matrix of size (left_num_neurons, right_num_neurons), a bias vector of size (right_num_neurons, 1), and a transfer function transfer_function. """ print '>>> Creating VectorNeuron: (%s, %s) %s' % \ (left_num_neurons, right_num_neurons, transfer_function) self.__weight_matrix = Matrix(rand(right_num_neurons, left_num_neurons)) self.__weight_matrix_backup = self.__weight_matrix.copy() self.__bias_vector = Matrix(rand(right_num_neurons, 1)) self.__delta_w_matrix = Matrix(rand(right_num_neurons, left_num_neurons)) self.__mersenne_twister = MersenneTwister() self.__mersenne_twister.seed(int(1000*time.time())) self.__transfer_function = transfer_function def neuron_compute(self, input_matrix): """Computes the vectorneuron output for input_matrix""" self.__result = self.__weight_matrix * input_matrix current_value = None transfer_function = self.__transfer_function row_dim = self.__weight_matrix.shape[0] input_col_dim = input_matrix.shape[1] for i in range(0,row_dim): for j in range(0, input_col_dim): current_value = self.__result[i, j] self.__result[i, j]= self.__bias_vector[i, 0] + current_value cmd = "self.%s(current_value)" % transfer_function self.__result[i, j] = eval(cmd) def compute_delta_w(self, m, lr): """Computes new delta_w matrix""" k = 0 delta_w = None delta_w_row_dim = self.__delta_w_matrix.shape[0] delta_w_col_dim = self.__delta_w_matrix.shape[1] for i in range(0, delta_w_row_dim): for j in range(0,delta_w_col_dim): k = abs(self.__mersenne_twister.randint(0,math.pow(2,32)) % m) if k == 0: delta_w = lr elif k == 1: delta_w = -1.0 * lr else: delta_w = 0.0 self.__delta_w_matrix[i, j] = delta_w def compute_delta_w_annealing(self, n, m, lr): """Computes new delta_w matrix (annealing style)""" k = 0 delta_w = None delta_w_row_dim = self.__delta_w_matrix.shape[0] for i in range(0,delta_w_row_dim): delta_w_matrix_col = self.__delta_w_matrix.shape[1] for j in range(0, delta_w_matrix_col): k = abs(self.__mersenne_twister.randint(0,math.pow(2,32)) % m) if k < n: if k % 2 == 0: if (k == 0): delta_w = lr else: delta_w = lr / k elif k % 2 == 1: delta_w = -1.0 * lr / k else: delta_w = 0.0 else: delta_w = 0.0 self.__delta_w_matrix[i, j] = delta_w def logsig(self, x): """Returns logsig of a single variable x""" return 1.0/(1.0 + exp(-1.0 * x)) def purelin(self, x): """Returns purelin of a single variable x""" return x def tansig(self, x): """Returns tansig of a single variable x""" return 2.0/exp(1.0 + exp(-2.0 * x), -1.0) def linsig(self, x): """Returns linsig of a single variable x""" if x <= 1.0 and x >= -1.0: return x if x > 1: return 1.0 else: return -1.0 def change_weights(self): """Changes weight_matrix by adding delta_w_matrix""" #print 'weight_matrix orig' #print self.__weight_matrix self.__weight_matrix = self.__weight_matrix + self.__delta_w_matrix #print 'weight matrix new' #print self.__weight_matrix def rollback_weights(self): """Reset weight_matrix to weight_matrix_backup""" #print 'resetting weights' self.__weight_matrix = self.__weight_matrix_backup.copy() def weight_matrix_backup(self): """Copies the current weight_matrix to weight_matrix_backup""" self.__weight_matrix_backup = self.__weight_matrix.copy() def get_bias(self): """Returns the vectorneuron's bias vector""" return self.__bias_vector def get_delta_w(self): """Return the computed delta_w matrix used to alter the weights""" return self.__delta_w_matrix def get_result(self): """Returns the output of vectorneuron's neuron_compute function""" return self.__result def get_weight_matrix(self): """Returns the vectorneuron's current weight_matrix""" return self.__weight_matrix def get_weight_matrix_backup(self): """Returns a backup of the vectorneuron's previous weight_matrix""" return self.__weight_matrix_backup def get_transfer_function(self): """Returns the vectorneuron's transfer function""" return self.__transfer_function def write_weight_to_file(self, filename): """Write the vectorneuron's weight_matrix to filename """ savetxt(filename, self.__weight_matrix) return True def write_bias_to_file(self, filename): """Write the vectorneuron's biias vector to filename""" savetxt(filename, self.__bias_vector) return True