def test_rotated_img(): """ The harris filter should yield the same results with an image and it's rotation. """ im = img_as_float(cp.asarray(data.astronaut().mean(axis=2))) im_rotated = im.T # # Moravec # results = peak_local_max(corner_moravec(im), # min_distance=10, threshold_rel=0) # results_rotated = peak_local_max(corner_moravec(im_rotated), # min_distance=10, threshold_rel=0) # assert (cp.sort(results[:, 0]) == cp.sort(results_rotated[:, 1])).all() # assert (cp.sort(results[:, 1]) == cp.sort(results_rotated[:, 0])).all() # Harris results = cp.nonzero(corner_harris(im)) results_rotated = cp.nonzero(corner_harris(im_rotated)) assert (cp.sort(results[0]) == cp.sort(results_rotated[1])).all() assert (cp.sort(results[1]) == cp.sort(results_rotated[0])).all() # Shi-Tomasi results = cp.nonzero(corner_shi_tomasi(im)) results_rotated = cp.nonzero(corner_shi_tomasi(im_rotated)) assert (cp.sort(results[0]) == cp.sort(results_rotated[1])).all() assert (cp.sort(results[1]) == cp.sort(results_rotated[0])).all()
def test_indices_with_labels(self): image = cp.asarray(np.random.uniform(size=(40, 60))) i, j = cp.mgrid[0:40, 0:60] labels = 1 + (i >= 20) + (j >= 30) * 2 i, j = cp.mgrid[-3:4, -3:4] footprint = i * i + j * j <= 9 expected = cp.zeros(image.shape, float) for imin, imax in ((0, 20), (20, 40)): for jmin, jmax in ((0, 30), (30, 60)): expected[imin:imax, jmin:jmax] = ndi.maximum_filter(image[imin:imax, jmin:jmax], footprint=footprint) expected = cp.column_stack(cp.nonzero(expected == image)) expected = expected[cp.argsort(image[tuple(expected.T)])[::-1]] result = peak.peak_local_max( image, labels=labels, min_distance=1, threshold_rel=0, footprint=footprint, indices=True, exclude_border=False, ) result = result[cp.argsort(image[tuple(result.T)])[::-1]] assert (result == expected).all()
def isolated_peaks_new(S1, params): """ takes a matrix of timepoints by channels S1 outputs threshold crossings that are relatively isolated from other peaks outputs row, column and magnitude of the threshold crossing """ S1 = cp.asarray(S1) # finding the local minimum in a sliding window within plus/minus loc_range extent # across time and across channels smin = my_min(S1, params.loc_range, [0, 1]) # the peaks are samples that achieve this local minimum, AND have negativities less # than a preset threshold peaks = (S1 < smin + 1e-3) & (S1 < params.spkTh) # only take local peaks that are isolated from other local peaks # if there is another local peak close by, this sum will be at least 2 sum_peaks = my_sum(peaks, params.long_range, [0, 1]) # set to 0 peaks that are not isolated, and multiply with the voltage values peaks = peaks * (sum_peaks < 1.2) * S1 # exclude temporal buffers peaks[:params.nt0, :] = 0 peaks[-params.nt0:, :] = 0 # find the non-zero peaks, and take their amplitudes col, row = cp.nonzero(peaks.T) # invert the sign of the amplitudes mu = -peaks[row, col] return row, col, mu
def nonzero(x: Array, /) -> Tuple[Array, ...]: """ Array API compatible wrapper for :py:func:`np.nonzero <numpy.nonzero>`. See its docstring for more information. """ return tuple(Array._new(i) for i in np.nonzero(x._array))
def analize(x): print("the following elements are nonzero") idx_nonzero = cupy.nonzero(x) nonzero = x[idx_nonzero] nonzero_cpu = cupy.asnumpy(nonzero) bits = np.unpackbits(nonzero_cpu) print(idx_nonzero) print(bits)
def cluster(self,maxClust): D = self.corrDist() Z = linkage(D[cupy.nonzero(~cupy.tri(self.n, k=0, dtype=bool))]) # create a linkage matrix based on the distance matrix if maxClust < 1: maxClust = 1 if maxClust > self.n: maxClust = self.n map = self.__breakClust__(to_tree(Z),maxClust) return map
def _preprocess(labels): label_values, inv_idx = cp.unique(labels, return_inverse=True) if not (label_values == 0).any(): warn('Random walker only segments unlabeled areas, where ' 'labels == 0. No zero valued areas in labels were ' 'found. Returning provided labels.', stacklevel=2) return labels, None, None, None, None # If some labeled pixels are isolated inside pruned zones, prune them # as well and keep the labels for the final output null_mask = labels == 0 pos_mask = labels > 0 mask = labels >= 0 fill = ndi.binary_propagation(null_mask, mask=mask) isolated = cp.logical_and(pos_mask, cp.logical_not(fill)) pos_mask[isolated] = False # If the array has pruned zones, be sure that no isolated pixels # exist between pruned zones (they could not be determined) if label_values[0] < 0 or cp.any(isolated): # synchronize! isolated = cp.logical_and( cp.logical_not(ndi.binary_propagation(pos_mask, mask=mask)), null_mask) labels[isolated] = -1 if cp.all(isolated[null_mask]): warn('All unlabeled pixels are isolated, they could not be ' 'determined by the random walker algorithm.', stacklevel=2) return labels, None, None, None, None mask[isolated] = False mask = cp.atleast_3d(mask) else: mask = None # Reorder label values to have consecutive integers (no gaps) zero_idx = cp.searchsorted(label_values, cp.array(0)) labels = cp.atleast_3d(inv_idx.reshape(labels.shape) - zero_idx) nlabels = label_values[zero_idx + 1:].shape[0] inds_isolated_seeds = cp.nonzero(isolated) isolated_values = labels[inds_isolated_seeds] return labels, nlabels, mask, inds_isolated_seeds, isolated_values
def svm_loss_vectorized(W, X, y, reg): """ Structured SVM loss function, vectorized implementation. Inputs and outputs are the same as svm_loss_naive. """ #covert to cupy X = cp.array(X) W = cp.array(W) y = cp.array(y) loss = 0.0 dW = cp.zeros(W.shape) # initialize the gradient as zero ############################################################################# # TODO: # # Implement a vectorized version of the structured SVM loss, storing the # # result in loss. # ############################################################################# # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)***** num_train = X.shape[0] num_classes = W.shape[1] scores = cp.dot(X,W) correct_class_scores = scores[cp.arange(num_train),y][:,cp.newaxis] margin = cp.maximum(0, scores - correct_class_scores + 1) margin[cp.arange(num_train),y] = 0 #ignore the margin for correct class of each picture loss = cp.sum(margin) loss /= num_train loss += reg * cp.sum(W*W) # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)***** ############################################################################# # TODO: # # Implement a vectorized version of the gradient for the structured SVM # # loss, storing the result in dW. # # # # Hint: Instead of computing the gradient from scratch, it may be easier # # to reuse some of the intermediate values that you used to compute the # # loss. # ############################################################################# # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)***** index_valid_margin = cp.nonzero(margin) margin[index_valid_margin] = 1 valid_margin_sum = cp.sum(margin,axis=1) margin[cp.arange(num_train),y] -= valid_margin_sum dW = cp.transpose(X).dot(margin) dW /= num_train dW += reg * 2 * W # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)***** return cp.asnumpy(loss), cp.asnumpy(dW)
def filter_by_distance_less(s_p, i_p): t0 = time.time() dists = get_absolute_values(i_p) t1 = time.time() mask = map_dists_less(dists) indices = np.nonzero(mask) s_p = s_p[indices] i_p = i_p[indices] t2 = time.time() # print() # print("%.4f\t%.4f\t%d" % (t1-t0, t2-t1, np.sum(dists < 25))) return s_p, i_p
def argrelextrema(data, comparator, axis=0, order=1, mode="clip"): """ Calculate the relative extrema of `data`. Parameters ---------- data : ndarray Array in which to find the relative extrema. comparator : callable Function to use to compare two data points. Should take two arrays as arguments. axis : int, optional Axis over which to select from `data`. Default is 0. order : int, optional How many points on each side to use for the comparison to consider ``comparator(n, n+x)`` to be True. Returns ------- extrema : tuple of ndarrays Indices of the maxima in arrays of integers. ``extrema[k]`` is the array of indices of axis `k` of `data`. Note that the return value is a tuple even when `data` is one-dimensional. See Also -------- argrelmin, argrelmax Examples -------- >>> from cusignal import argrelextrema >>> import cupy as cp >>> x = cp.array([2, 1, 2, 3, 2, 0, 1, 0]) >>> argrelextrema(x, cp.greater) (array([0, 3, 6]),) >>> y = cp.array([[1, 2, 1, 2], ... [2, 2, 0, 0], ... [5, 3, 4, 4]]) ... >>> argrelextrema(y, cp.less, axis=1) (array([0, 0, 2]), array([0, 2, 1])) """ data = cp.asarray(data) results = _boolrelextrema(data, comparator, axis, order, mode) if mode == "raise": raise NotImplementedError( "CuPy `take` doesn't support `mode='raise'`.") return cp.nonzero(results)
def argrelextrema(data, comparator, axis=0, order=1): """ Calculate the relative extrema of `data`. Parameters ---------- data : ndarray Array in which to find the relative extrema. comparator : callable Function to use to compare two data points. Should take two arrays as arguments. axis : int, optional Axis over which to select from `data`. Default is 0. order : int, optional How many points on each side to use for the comparison to consider ``comparator(n, n+x)`` to be True. Returns ------- extrema : tuple of ndarrays Indices of the maxima in arrays of integers. ``extrema[k]`` is the array of indices of axis `k` of `data`. Note that the return value is a tuple even when `data` is one-dimensional. See Also -------- argrelmin, argrelmax Notes ----- .. versionadded:: 0.11.0 Examples -------- >>> from scipy.signal import argrelextrema >>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0]) >>> argrelextrema(x, np.greater) (array([3, 6]),) >>> y = np.array([[1, 2, 1, 2], ... [2, 2, 0, 0], ... [5, 3, 4, 4]]) ... >>> argrelextrema(y, np.less, axis=1) (array([0, 2]), array([2, 1])) """ data = cp.asarray(data) results = _boolrelextrema(data, comparator, axis, order) return cp.nonzero(results)
def _get_high_intensity_peaks(image, mask, num_peaks): """ Return the highest intensity peak coordinates. """ # get coordinates of peaks coord = cp.nonzero(mask) intensities = image[coord] # Highest peak first idx_maxsort = cp.argsort(-intensities) coord = cp.column_stack(coord)[idx_maxsort] # select num_peaks peaks if len(coord) > num_peaks: coord = coord[:num_peaks] return coord
def _get_high_intensity_peaks(image, mask, num_peaks, min_distance, p_norm): """ Return the highest intensity peak coordinates. """ # get coordinates of peaks coord = cp.nonzero(mask) intensities = image[coord] # Highest peak first idx_maxsort = cp.argsort(-intensities) coord = cp.column_stack(coord)[idx_maxsort] coord = ensure_spacing(coord, spacing=min_distance, p_norm=p_norm) if len(coord) > num_peaks: coord = coord[:num_peaks] return coord
def diagonal(self, k=0): """Returns the k-th diagonal of the matrix. Args: k (int, optional): Which diagonal to get, corresponding to elements a[i, i+k]. Default: 0 (the main diagonal). Returns: cupy.ndarray : The k-th diagonal. """ rows, cols = self.shape if k <= -rows or k >= cols: return cupy.empty(0, dtype=self.data.dtype) idx, = cupy.nonzero(self.offsets == k) first_col, last_col = max(0, k), min(rows + k, cols) if idx.size == 0: return cupy.zeros(last_col - first_col, dtype=self.data.dtype) return self.data[idx[0], first_col:last_col]
def auc(vector_predict, vector_true, gpu=False): if gpu: vector_predict = cp.array(vector_predict) vector_true = cp.array(vector_true) pos_indexes = cp.where(vector_true == 1)[0] sort_indexes = cp.argsort(vector_predict) rank = cp.nonzero(cp.in1d(sort_indexes, pos_indexes))[0] return (cp.sum(rank) - len(pos_indexes) * (len(pos_indexes) + 1) / 2) / ( len(pos_indexes) * (len(vector_predict) - len(pos_indexes))) else: pos_indexes = np.where(vector_true == 1)[0] sort_indexes = np.argsort(vector_predict) rank = np.nonzero(np.in1d(sort_indexes, pos_indexes))[0] return (np.sum(rank) - len(pos_indexes) * (len(pos_indexes) + 1) / 2) / ( len(pos_indexes) * (len(vector_predict) - len(pos_indexes)))
def ent(wave, n, L, la): lb = L - la # convert the wavefunction into a matrix for SVD temp = cp.reshape(wave, (2**la, 2**lb)) # SVD for entanglement entropy, only singular values calculated sp = cp.linalg.svd(temp, compute_uv=False) tol = 1e-10 # chop small singular values to zero to avoid numerical instability sp[abs(sp) < tol] = 0.0 # choose only non-zero values to avoid feeding to log function sp = sp[cp.nonzero(sp)] el = sp**2 von = -cp.dot(el, np.log2(el)) ren = (1 / (1 - n)) * cp.log2(np.sum(el**(n))) # chop small values to zero if (abs(von) < tol): von = 0 if (abs(ren) < tol): ren = 0 # EE in log2 base return von, ren
def filter_by_distance_greater(s_p, i_p): # print(i_p.device) # mask2 = np.ones_like(mask).astype(np.bool) # print(mask, mask.dtype) # print(mask2, mask2.dtype) # print(np.equal(mask, mask2)) # t0 = time.time() dists = get_absolute_values(i_p) # t1 = time.time() # s_p = s_p[dists > 4] # dists = dists > 4 dists = map_dists_greater(dists) indices = np.nonzero(dists) # mask = np.nonzero(dists > 4) # t2 = time.time() s_p = s_p[indices] # t3 = time.time() # print() # print("get_absolute_values: %.4f\ncreate mask: %.4f\nfilter array: %.4f\nnumber of elements: %d" % (t1-t0, t2-t1, t3-t2, np.sum(dists > 4))) # return s_p return s_p
def __call__(self, x): """ Args: x (cp.ndarray): input data """ nz, ny, nx = x.shape grid_sz = ( int(ceil(nx / self._tile_width)), int(ceil(ny / self._tile_width)), int(ceil(nz / self._tile_width)), ) buf = cp.copy(x) if not isinstance(x.dtype, cp.uint16): logger.info(".. rescaling to uint16") buf = buf / buf.max() * 65535 buf = buf.astype(cp.uint16) threshold = np.uint16( self._threshold if self._threshold else FindPeak3D.find_threshold(buf) ) logger.debug(f".. threshold: {threshold}") self._kernels["find_peak_3d_kernel"]( grid_sz, (self._tile_width,) * 3, (buf, buf, threshold, nx, ny, nz) ) coords = cp.nonzero(buf) coords = [cp.asnumpy(_coords) for _coords in coords] logger.debug(f'found {len(coords[0])} candidates') peak_list = [] for coord in zip(*coords): print(coord) peak_list.append(coord) peak_list.sort(key=lambda x: x[0], reverse=True) return peak_list
def cupy_unique_axis0(array, return_counts=False): """ Support method as cupy currently doesn't support .unique + axis :param array: :param return_counts: :return: """ if len(array.shape) != 2: raise ValueError("Input array must be 2D.") sortarr = array[np.lexsort(array.T[::-1])] mask = np.empty(array.shape[0], dtype=np.bool_) mask[0] = True mask[1:] = np.any(sortarr[1:] != sortarr[:-1], axis=1) if return_counts: nonzero = np.nonzero(mask)[0] # may synchronize idx = np.empty((nonzero.size + 1, ), nonzero.dtype) idx[:-1] = nonzero idx[-1] = mask.size return sortarr[mask], idx[1:] - idx[:-1] else: return sortarr[mask]
def unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None): """ This implementation is copied from cupy 6.0.0.a Find the unique elements of an array. Returns the sorted unique elements of an array. There are three optional outputs in addition to the unique elements: * the indices of the input array that give the unique values * the indices of the unique array that reconstruct the input array * the number of times each unique value comes up in the input array Args: ar(array_like): Input array. This will be flattened if it is not already 1-D. return_index(bool, optional): If True, also return the indices of `ar` (along the specified axis, if provided, or in the flattened array) that result in the unique array. return_inverse(bool, optional): If True, also return the indices of the unique array (for the specified axis, if provided) that can be used to reconstruct `ar`. return_counts(bool, optional): If True, also return the number of times each unique item appears in `ar`. axis(int or None, optional): Not supported yet. Returns: cupy.ndarray or tuple: If there are no optional outputs, it returns the :class:`cupy.ndarray` of the sorted unique values. Otherwise, it returns the tuple which contains the sorted unique values and followings. * The indices of the first occurrences of the unique values in the original array. Only provided if `return_index` is True. * The indices to reconstruct the original array from the unique array. Only provided if `return_inverse` is True. * The number of times each of the unique values comes up in the original array. Only provided if `return_counts` is True. .. seealso:: :func:`numpy.unique` """ if axis is not None: raise NotImplementedError('axis option is not supported yet.') ar = cp.asarray(ar).flatten() if return_index or return_inverse: perm = ar.argsort() aux = ar[perm] else: ar.sort() aux = ar mask = cp.empty(aux.shape, dtype=cp.bool_) mask[0] = True mask[1:] = aux[1:] != aux[:-1] ret = aux[mask] if not return_index and not return_inverse and not return_counts: return ret ret = ret, if return_index: ret += perm[mask], if return_inverse: imask = cp.cumsum(mask) - 1 inv_idx = cp.empty(mask.shape, dtype=cp.intp) inv_idx[perm] = imask ret += inv_idx, if return_counts: nonzero = cp.nonzero(mask)[0] idx = cp.empty((nonzero.size + 1, ), nonzero.dtype) idx[:-1] = nonzero idx[-1] = mask.size ret += idx[1:] - idx[:-1], return ret
def test_argwhere(self): with testing.assert_warns(DeprecationWarning): return cupy.nonzero(self.array)
def coords(self): indices = cp.nonzero(self.image) return cp.vstack( [indices[i] + self.slice[i].start for i in range(self._ndim)]).T
def get_good_channels(raw_data=None, probe=None, params=None): """ of the channels indicated by the user as good (chanMap) further subset those that have a mean firing rate above a certain value (default is ops.minfr_goodchannels = 0.1Hz) needs the same filtering parameters in ops as usual also needs to know where to start processing batches (twind) and how many channels there are in total (NchanTOT) """ fs = params.fs fshigh = params.fshigh fslow = params.fslow Nbatch = get_Nbatch(raw_data, params) NT = params.NT spkTh = params.spkTh nt0 = params.nt0 minfr_goodchannels = params.minfr_goodchannels car_first = params.car_first car_type = params.car_type chanMap = probe.chanMap NchanTOT = len(chanMap) ich = [] k = 0 ttime = 0 # skip every 100 batches # TODO: move_to_config - every N batches for ibatch in tqdm(range(0, Nbatch, int(ceil(Nbatch / 100))), desc="Finding good channels"): i = NT * ibatch if (i + NT) > raw_data.shape[0]: break buff = raw_data[i:i + NT] # buff = _make_fortran(buff) # NOTE: using C order now assert buff.shape[0] > buff.shape[1] assert buff.flags.c_contiguous if buff.size == 0: break # Put on GPU. buff = cp.asarray(buff, dtype=np.float32) assert buff.flags.c_contiguous datr = gpufilter(buff, chanMap=chanMap, fs=fs, fshigh=fshigh, fslow=fslow, car_first=car_first, car_type=car_type) assert datr.shape[0] > datr.shape[1] # very basic threshold crossings calculation s = cp.std(datr, axis=0) datr = datr / s # standardize each channel ( but don't whiten) # TODO: move_to_config (30 sample range) mdat = my_min( datr, 30, 0) # get local minima as min value in +/- 30-sample range # take local minima that cross the negative threshold xi, xj = cp.nonzero((datr < mdat + 1e-3) & (datr < spkTh)) # filtering may create transients at beginning or end. Remove those. xj = xj[(xi >= nt0) & (xi <= NT - nt0)] # collect the channel identities for the detected spikes ich.append(xj) k += xj.size # keep track of total time where we took spikes from ttime += datr.shape[0] / fs ich = cp.concatenate(ich) # count how many spikes each channel got nc, _ = cp.histogram(ich, cp.arange(NchanTOT + 1)) # divide by total time to get firing rate nc = nc / ttime # keep only those channels above the preset mean firing rate igood = cp.asnumpy(nc >= minfr_goodchannels) if len(igood) == 0: raise RuntimeError( "No good channels found! Verify your raw data and parameters.") if np.sum(igood) == 0: raise RuntimeError( "No good channels found! Verify your raw data and parameters.") logger.info('Found %d threshold crossings in %2.2f seconds of data.' % (k, ttime)) logger.info('Found %d/%d bad channels.' % (np.sum(~igood), len(igood))) return igood
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batchsize', '-b', type=int, default=100, help='Number of examples in each mini-batch') parser.add_argument('--bproplen', '-l', type=int, default=200, help='Number of words in each mini-batch ' '(= length of truncated BPTT)') parser.add_argument('--epoch', '-e', type=int, default=40, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=0, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--file', default="enwik8", help='path to text file for training') parser.add_argument('--unit', '-u', type=int, default=2800, help='Number of LSTM units') parser.add_argument('--embd', type=int, default=400, help='Number of embedding units') parser.add_argument('--hdrop', type=float, default=0.2, help='hidden state dropout (variational)') parser.add_argument('--edrop', type=float, default=0.5, help='embedding dropout') args = parser.parse_args() nembd = args.embd #number of training iterations per model save, log write, and validation set evaluation interval =100 pdrop = args.hdrop pdrope = args.edrop #initial learning rate alpha0 = .001 #inverse of linear decay rate towards 0 dec_it = 12*9000 #minimum learning rate alpha_min = .00007 #first ntrain words of dataset will be used for training ntrain = 90000000 seqlen = args.bproplen nbatch = args.batchsize filename= args.file text,mapping = get_char(filename) sequence = np.array(text).astype(np.int32) itrain =sequence[0:ntrain] ttrain = sequence[1:ntrain+1] fullseql=int(ntrain/nbatch) itrain = itrain.reshape(nbatch,fullseql) ttrain = ttrain.reshape(nbatch,fullseql) #doesn't use full validations set nval = 500000 ival = sequence[ntrain:ntrain+nval] tval = sequence[ntrain+1:ntrain+nval+1] ival = ival.reshape(ival.shape[0]//1000,1000) tval = tval.reshape(tval.shape[0]//1000,1000) #test = sequence[ntrain+nval:ntrain+nval+ntest] nvocab = max(sequence) + 1 # train is just an array of integers print('#vocab =', nvocab) # Prepare an RNNLM model rnn = RNNForLM(nvocab, args.unit,args.embd) model = L.Classifier(rnn) model.compute_accuracy = False # we only want the perplexity if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() # make the GPU current model.to_gpu() # Set up an optimizer optimizer = Adam(alpha=alpha0) optimizer.setup(model) resultdir = args.out print('starting') nepoch = args.epoch start = 0 loss_sum = 0; if not os.path.isdir(resultdir): os.mkdir(resultdir) vloss = test(rnn,ival,tval) vloss= (1.4427*vloss) f = open(os.path.join(resultdir,'log'), 'w') outstring = "Initial Validation loss (bits/word): " + str(vloss) + '\n' f.write(outstring) f.close() i=0 epoch_num = 0 it_num = 0 while True: # Get the result of the forward pass. fin = start+seqlen if fin>(itrain.shape[1]): start = 0 fin = start+seqlen epoch_num = epoch_num+1 if epoch_num== nepoch: break inputs = itrain[:,start:fin] targets = ttrain[:,start:fin] start = fin inputs = Variable(inputs) targets = Variable(targets) targets.to_gpu() inputs.to_gpu() it_num+=1 loss = 0 rnn.applyWN() #make hidden dropout mask mask = cp.zeros((inputs.shape[0],args.unit),dtype = cp.float32) ind = cp.nonzero(cp.random.rand(inputs.shape[0],args.unit)>pdrop) mask[ind] = 1/(1-pdrop) #make embedding dropout mask mask2 = cp.zeros((inputs.shape[0],nembd),dtype = cp.float32) ind = cp.nonzero(cp.random.rand(inputs.shape[0],nembd)>pdrope) mask2[ind] = 1/(1-pdrope) for j in range(seqlen): output = rnn(inputs[:,j],mask,mask2) loss = loss+ F.softmax_cross_entropy(output,targets[:,j]) loss = loss/(seqlen) # Zero all gradients before updating them. rnn.zerograds() loss_sum += loss.data # Calculate and update all gradients. loss.backward() s = 0; # Use the optmizer to move all parameters of the network # to values which will reduce the loss. optimizer.update() #decays learning rate linearly optimizer.alpha = alpha0*(dec_it-it_num)/float(dec_it) #prevents learning rate from going below minumum if optimizer.alpha<alpha_min: optimizer.alpha = alpha_min loss.unchain_backward() if ((i+1)%interval) ==0: rnn.reset_state() vloss = test(rnn,ival,tval) #converts to binary entropy vloss= (1.4427*vloss) loss_sum = (1.4427*loss_sum/interval) serializers.save_npz(os.path.join(resultdir,'model'),rnn) outstring = "Training iteration: " + str(i+1) + " Training loss (bits/char): " + str(loss_sum) + " Validation loss (bits/word): " + str(vloss) + '\n' f = open(os.path.join(resultdir,'log'), 'a') f.write(outstring) f.close() print("Training iteration: " + str(i+1)) print('training loss: ' + str(loss_sum)) print('validation loss: ' + str(vloss)) loss_sum=0 i+=1
def admittanceMatrixE(self): shapeParams = self.shapeFunctionParameters() whereIsZero = (cp.absolute(shapeParams) - 1e-12 < 0) indexZero = cp.where(whereIsZero) isConst = indexZero[2] == 2 # 1 for const x, 0 for const y indicesConstX = cp.where(isConst)[0] indicesConstY = cp.where(~isConst)[0] sortedElNodeIndices = cp.sort(self.nodeisElectrode[self.isValid], axis=1) admittanceMatrixE = cp.zeros((self.n_pts, self.ne)) shapeMatrix = cp.zeros((shapeParams.shape[0], shapeParams.shape[1], 2)) integratingMatrix = cp.zeros((shapeParams.shape[0], 2)) shapeMatrix[indicesConstY, :, 0] = shapeParams[indicesConstY, :, 0] + shapeParams[indicesConstY, :, 2] * self.pts[sortedElNodeIndices, :][indicesConstY, 1, 1][:, None] shapeMatrix[indicesConstY, :, 1] = shapeParams[indicesConstY, :, 1] shapeMatrix[indicesConstX, :, 0] = shapeParams[indicesConstX, :, 0] + shapeParams[indicesConstX, :, 1] * self.pts[sortedElNodeIndices, :][indicesConstX, 1, 0][:, None] shapeMatrix[indicesConstX, :, 1] = shapeParams[indicesConstX, :, 2] integratingMatrix[indicesConstY, 0] = self.pts[sortedElNodeIndices, :][indicesConstY, 1, 0] - self.pts[sortedElNodeIndices, :][indicesConstY, 0, 0] integratingMatrix[indicesConstY, 1] = 0.5 * (cp.power(self.pts[sortedElNodeIndices, :][indicesConstY, 1, 0], 2) - cp.power(self.pts[sortedElNodeIndices, :][indicesConstY, 0, 0], 2)) integratingMatrix[indicesConstX, 0] = self.pts[sortedElNodeIndices, :][indicesConstX, 1, 1] - self.pts[sortedElNodeIndices, :][indicesConstX, 0, 1] integratingMatrix[indicesConstX, 1] = 0.5 * (cp.power(self.pts[sortedElNodeIndices, :][indicesConstX, 1, 1], 2) - cp.power(self.pts[sortedElNodeIndices, :][indicesConstX, 0, 1], 2)) #print(integratingMatrix.shape) integrals = cp.einsum('ijk, ik -> ij', shapeMatrix, integratingMatrix) integrals[:] = cp.absolute(integrals) #integr = cp.sum(cp.multiply(shapeMatrix, integratingMatrix[:, None]), axis=2) #print(cp.sum(cp.round_(integrals, 16) == cp.round_(integr, 16))) indexElectrode = sortedElNodeIndices[:, 0] // self.n_per_el #print(indexElectrode) integrals = - integrals / self.z[indexElectrode][:, None, None] integrals = integrals.ravel() indexElectrode = cp.tile(indexElectrode, (self.n_per_el, 1)).T.ravel() #print(self.tri[twoFromElectrode][isValid]) indexNode = self.tri[self.twoFromElectrode][self.isValid].ravel() #admittanceMatrixE [self.tri[twoFromElectrode][isValid].ravel(), indexElectrode] += integrals.ravel() indSort = cp.argsort(indexNode) indexNode = indexNode[indSort] indexElectrode = indexElectrode[indSort] integrals = integrals[indSort] unique, counts = cp.unique(indexNode, return_counts=True) #print("number of unique entries", unique.shape) #print("counts \n", counts) index_pointer = cp.zeros(self.n_pts + 1) sum_count = cp.cumsum(counts) #print(sum_count) index_pointer[unique[:]+1] = sum_count[:] #print(index_pointer) nonzeroes = cp.nonzero(index_pointer)[0] #print(nonzeroes) mask = cp.zeros(index_pointer.shape[0], dtype='b1') mask[nonzeroes] = True mask[0] = True zeroes = cp.where(~mask)[0] #time_loop = time() while (index_pointer[1:]==0).any(): index_pointer[zeroes] = index_pointer[zeroes - 1] '''for i in range(index_pointer.shape[0]): if i == 0: continue elif index_pointer[i] == 0: index_pointer[i] = index_pointer[i-1]''' #print('time for loop ',time()-time_loop) index_pointer2 = cp.arange(self.n_pts + 1) #print('indexEl', indexElectrode) #print(index_pointer.shape) admittanceMatrixE = sp.csr_matrix((integrals, indexElectrode, index_pointer), shape=(self.n_pts, self.ne), dtype=integrals.dtype) adm = admittanceMatrixE.toarray(); #print(integrals) #print(indexNode) #print(indexElectrode) #a = (sortedElNodeIndices[0,0]) #print(adm[4]) # print(adm[:,1]) #print('sum zeroes ',cp.sum(adm>0)) return adm;
def time_nonzero(self): np.nonzero(self.b)
def _correlate_or_convolve( input, weights, output, mode, cval, origin, convolution, dtype_mode, use_weights_mask=False, ): # if use_weights_mask: # raise NotImplementedError("TODO") origins, int_type = _check_nd_args(input, weights, mode, origin) if weights.size == 0: return cupy.zeros_like(input) if convolution: weights = weights[tuple([slice(None, None, -1)] * weights.ndim)] origins = list(origins) for i, wsize in enumerate(weights.shape): origins[i] = -origins[i] if wsize % 2 == 0: origins[i] -= 1 origins = tuple(origins) elif weights.dtype.kind == "c": # numpy.correlate conjugates weights rather than input. weights = weights.conj() if dtype_mode == "numpy": # This "numpy" mode is used by cupyimg.scipy.signal.signaltools # numpy.convolve and correlate do not always cast to floats dtype = cupy.promote_types(input.dtype, weights.dtype) output_dtype = dtype if dtype.char == "e": # promote internal float type to float32 for accuracy dtype = "f" if output is not None: raise ValueError( "dtype_mode == 'numpy' does not support the output " "argument") weight_dtype = dtype if weights.dtype != dtype: weights = weights.astype(dtype) if input.dtype != dtype: input = input.astype(dtype) output = cupy.zeros(input.shape, output_dtype) weight_dtype = dtype else: if weights.dtype.kind == "c" or input.dtype.kind == "c": if dtype_mode == "ndimage": weight_dtype = cupy.complex128 elif dtype_mode == "float": weight_dtype = cupy.promote_types(input.real.dtype, cupy.complex64) else: if dtype_mode == "ndimage": weight_dtype = cupy.float64 elif dtype_mode == "float": weight_dtype = cupy.promote_types(input.real.dtype, cupy.float32) weight_dtype = cupy.dtype(weight_dtype) output = _util._get_output(output, input, None, weight_dtype) unsigned_output = output.dtype.kind in ["u", "b"] if use_weights_mask: input = cupy.ascontiguousarray(input) # The kernel needs only the non-zero kernel values and their coordinates. # This allows us to use a single for loop to compute the ndim convolution. # The loop will be over only the the non-zero entries of the filter. weights = cupy.ascontiguousarray(weights, weight_dtype) wlocs = cupy.nonzero(weights) wvals = weights[wlocs] # (nnz,) array of non-zero values wlocs = cupy.stack( wlocs) # (ndim, nnz) array of indices for these values return _get_correlate_kernel_masked( mode, cval, input.shape, weights.shape, wvals.size, tuple(origins), unsigned_output, )(input, wlocs, wvals, output) else: if mode == "constant": # TODO: negative strides gives incorrect result for constant mode # so make sure input is C contiguous. input = cupy.ascontiguousarray(input) kernel = _get_correlate_kernel(mode, weights.shape, int_type, origins, cval, unsigned_output) return _call_kernel(kernel, input, weights, output, weight_dtype)
def get_sentence_boundaries(metadata_df, token_ar, stride, fs_index_ls): """ Given token array and meta-data we create sentence boundaries We consider a sentence boundary as one which is at eol-chars (`##.`,`.`) or start/end of a review """ seq_len = token_ar.shape[1] fullstop_flag = None for fs_token_idx in fs_index_ls: if fullstop_flag is None: fullstop_flag = token_ar == fs_token_idx else: fullstop_flag = (fullstop_flag) | (token_ar == fs_token_idx) fullstop_row, fullstop_col = cp.nonzero(fullstop_flag) min_row_df = ( metadata_df.groupby("input_text_index").seq_row.min().reset_index( drop=False)) min_row_df.rename(columns={"seq_row": "min_row"}, inplace=True) max_row_df = ( metadata_df.groupby("input_text_index").seq_row.max().reset_index( drop=False)) max_row_df.rename(columns={"seq_row": "max_row"}, inplace=True) metadata_df = metadata_df.merge(min_row_df).merge(max_row_df) ### Can filter to only sequences that have the org ## if below becomes a bottleneck fullstop_df = cudf.DataFrame() fullstop_df["seq_row"] = cudf.Series(fullstop_row) fullstop_df["fs_seq_col"] = cudf.Series(fullstop_col) fullstop_df = fullstop_df.merge(metadata_df) fullstop_df.rename(columns={"seq_row": "fs_seq_row"}, inplace=True) first_row_df = cudf.DataFrame() first_row_df["input_text_index"] = min_row_df["input_text_index"] first_row_df["fs_seq_row"] = min_row_df["min_row"] first_row_df["fs_seq_col"] = 1 first_row_df["min_row"] = min_row_df["min_row"] first_row_df = first_row_df.merge( max_row_df[["input_text_index", "max_row"]]) last_row_df = cudf.DataFrame() last_row_df["input_text_index"] = max_row_df["input_text_index"] last_row_df["fs_seq_row"] = max_row_df["max_row"] last_row_df["fs_seq_col"] = seq_len - 1 last_row_df["max_row"] = max_row_df["max_row"] last_row_df = last_row_df.merge(min_row_df[["input_text_index", "min_row"]]) fullstop_df = cudf.concat([fullstop_df, first_row_df, last_row_df]) ## -2-> for padding valid_region = (seq_len - 2) - stride + 1 ### only keep sentences in the valid_region valid_flag = fullstop_df["fs_seq_col"] < valid_region valid_flag = valid_flag | (fullstop_df["fs_seq_row"] == fullstop_df["max_row"]) fullstop_df = fullstop_df[valid_flag] fullstop_df["flat_loc_fs"] = (fullstop_df["fs_seq_row"] * seq_len + fullstop_df["fs_seq_col"]) return fullstop_df[[ "input_text_index", "fs_seq_row", "fs_seq_col", "flat_loc_fs" ]]
def check_batch(batch): idx_nonzero = cupy.nonzero(batch)[0] # nonzero = batch[idx_nonzero] # nonzero_cpu = cupy.asnumpy(nonzero) # bits = np.unpackbits(nonzero_cpu) return idx_nonzero
import time import sys import os import scipy.misc # import numpy as np import cupy as np # from numba import vectorize, float64 # import numba abs2 = np.ElementwiseKernel( 'complex64 x', 'float32 y', 'y = isfinite(x) ? x.real()*x.real() + x.imag()*x.imag() : 100', 'abs2', False) abs2.__call__(np.array([1 + 1j]).astype(np.complex64)) np.nonzero(np.array([1]).astype(np.float32)) map_dists_greater = np.ElementwiseKernel('float32 x', 'bool y', 'y = x > 4', 'map_dists_greater', False) map_dists_greater.__call__(np.array([1]).astype(np.float32)) map_dists_less = np.ElementwiseKernel('float32 x', 'bool y', 'y = x < 25', 'map_dists_less', False) map_dists_less.__call__(np.array([1]).astype(np.float32)) def get_random_points(x_min, x_max, y_min, y_max, n_points): s_p = np.random.random((n_points, 2), dtype=np.float32) s_p[:, 0] *= y_max - y_min + 0 s_p[:, 1] *= x_max - x_min + 2 s_p[:, 0] += y_min - 0 s_p[:, 1] += x_min - 1 # s_p[:,0] *= 3.0