我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.hstack()。
def __SubDoWavelets(self,waveforms): scales = 4 dimensions = 10 nspk,ls = waveforms.shape cc = pywt.wavedec(waveforms,"haar",mode="symmetric",level=scales,axis=-1) cc = np.hstack(cc) sd = list() for i in range(ls): test_data = cc[:,i] thr_dist = np.std(test_data,ddof=1)*3 thr_dist_min = np.mean(test_data)-thr_dist thr_dist_max = np.mean(test_data)+thr_dist aux = test_data[(test_data>thr_dist_min)&(test_data<thr_dist_max)] if aux.size > 10: sd.append(self.__test_ks(aux)) else: sd.append(0) ind = np.argsort(sd) ind = ind[::-1] coeff = ind[:dimensions] waveletspk = cc[:,coeff] return waveletspk
def applyFilter(data, b, a, padding=100, bidir=True): """Apply a linear filter with coefficients a, b. Optionally pad the data before filtering and/or run the filter in both directions.""" try: import scipy.signal except ImportError: raise Exception("applyFilter() requires the package scipy.signal.") d1 = data.view(np.ndarray) if padding > 0: d1 = np.hstack([d1[:padding], d1, d1[-padding:]]) if bidir: d1 = scipy.signal.lfilter(b, a, scipy.signal.lfilter(b, a, d1)[::-1])[::-1] else: d1 = scipy.signal.lfilter(b, a, d1) if padding > 0: d1 = d1[padding:-padding] if (hasattr(data, 'implements') and data.implements('MetaArray')): return MetaArray(d1, info=data.infoCopy()) else: return d1
def pull_item(self, index): img_id = self.ids[index] target = ET.parse(self._annopath % img_id).getroot() img = cv2.imread(self._imgpath % img_id) height, width, channels = img.shape if self.target_transform is not None: target = self.target_transform(target, width, height) if self.transform is not None: target = np.array(target) img, boxes, labels = self.transform(img, target[:, :4], target[:, 4]) # to rgb img = img[:, :, (2, 1, 0)] # img = img.transpose(2, 0, 1) target = np.hstack((boxes, np.expand_dims(labels, axis=1))) return torch.from_numpy(img).permute(2, 0, 1), target, height, width # return torch.from_numpy(img), target, height, width
def text_to_char_array(original): r""" Given a Python string ``original``, remove unsupported characters, map characters to integers and return a numpy array representing the processed string. """ # Create list of sentence's words w/spaces replaced by '' result = original.replace(" '", "") # TODO: Deal with this properly result = result.replace("'", "") # TODO: Deal with this properly result = result.replace(' ', ' ') result = result.split(' ') # Tokenize words into letters adding in SPACE_TOKEN where required result = np.hstack([SPACE_TOKEN if xt == '' else list(xt) for xt in result]) # Map characters into indicies result = np.asarray([SPACE_INDEX if xt == SPACE_TOKEN else ord(xt) - FIRST_INDEX for xt in result]) # Add result to results return result
def text_to_char_array(original): r""" Given a Python string ``original``, remove unsupported characters, map characters to integers and return a numpy array representing the processed string. """ # Create list of sentence's words w/spaces replaced by '' result = original.replace(" '", "") # TODO: Deal with this properly result = result.replace("'", "") # TODO: Deal with this properly result = result.replace(' ', ' ') result = result.split(' ') # Tokenize words into letters adding in SPACE_TOKEN where required result = np.hstack([SPACE_TOKEN if xt == '' else list(xt) for xt in result]) # Map characters into indicies result = np.asarray([SPACE_INDEX if xt == SPACE_TOKEN else ( ord(xt) - FIRST_INDEX if ord(xt)>FIRST_INDEX else 27+int(xt)) for xt in result]) # Add result to results return result
def plot_electrodes(self): if not getattr(self, 'collections', None): # It is important to set one facecolor per point so that we can change # it later self.electrode_collection = self.electrode_ax.scatter(self.x_position, self.y_position, facecolor=['black' for _ in self.x_position], s=30) self.electrode_ax.set_xlabel('Space [um]') self.electrode_ax.set_xticklabels([]) self.electrode_ax.set_ylabel('Space [um]') self.electrode_ax.set_yticklabels([]) else: self.electrode_collection.set_offsets(np.hstack([self.x_position[np.newaxis, :].T, self.y_position[np.newaxis, :].T])) ax, x, y = self.electrode_ax, self.y_position, self.x_position ymin, ymax = min(x), max(x) yrange = (ymax - ymin)*0.5 * 1.05 # stretch everything a bit ax.set_ylim((ymax + ymin)*0.5 - yrange, (ymax + ymin)*0.5 + yrange) xmin, xmax = min(y), max(y) xrange = (xmax - xmin)*0.5 * 1.05 # stretch everything a bit ax.set_xlim((xmax + xmin)*0.5 - xrange, (xmax + xmin)*0.5 + xrange) self.ui.raw_data.draw_idle()
def read_image(imagery_path): # Read image dataset = gdal.Open(imagery_path) dsmatrix = dataset.ReadAsArray(xoff=0, yoff=0, xsize=dataset.RasterXSize, ysize=dataset.RasterYSize) # Get Geographic meta data geo_trans_list = dataset.GetGeoTransform() proj_str = dataset.GetProjection() num_bands = dataset.RasterCount # Adapt to one bands or multi-bands if num_bands > 1: # Unfold array into pandas DataFrame rows = dsmatrix.shape[1] cols = dsmatrix.shape[2] data_array = dsmatrix[:,0,:] for irow in range(1,rows): tempmatirx = dsmatrix[:,irow,:] data_array = np.hstack((data_array,tempmatirx)) else: # Unfold array into pandas DataFrame rows = dsmatrix.shape[0] cols = dsmatrix.shape[1] data_array = dsmatrix[0,:] for irow in range(1,rows): tempmatirx = dsmatrix[irow,:] data_array = np.hstack((data_array,tempmatirx)) data_frame = pd.DataFrame(data_array.T) return data_frame, rows, cols, geo_trans_list, proj_str, num_bands
def KeyGen(**kwargs): ''' Appendix B of BLISS paper m_bar = m + n o/p: A: Public Key n x m' numpy array S: Secret Key m'x n numpy array ''' q, n, m, alpha = kwargs['q'], kwargs['n'], kwargs['m'], kwargs['alpha'] Aq_bar = util.crypt_secure_matrix(-(q-1)/2, (q-1)/2, n, m) S_bar = util.crypt_secure_matrix(-(2)**alpha, (2)**alpha, m, n) # alpha is small enough, we need not reduce (modq) S = np.vstack((S_bar, np.eye(n, dtype = int))) # dimension is m_bar x n, Elements are in Z mod(2q) A = np.hstack((2*Aq_bar, q * np.eye(n, dtype = int) - 2*np.matmul(Aq_bar,S_bar))) # dimension is n x m_bar , Elements are in Z mod(2q) #return util.matrix_to_Zq(A, 2*q), S, Aq_bar, S_bar return util.matrix_to_Zq(A, 2*q), S
def repeat(tensor: tf.Tensor, repeats: int, axis: int) -> tf.Tensor: """ Repeat elements of the input tensor in the specified axis ``repeats``-times. .. note:: Chaining of this op may produce TF warnings although the performance seems to be unaffected. :param tensor: TF tensor to be repeated :param repeats: number of repeats :param axis: axis to repeat :return: tensor with repeated elements """ shape = tensor.get_shape().as_list() dims = np.arange(len(tensor.shape)) prepare_perm = np.hstack(([axis], np.delete(dims, axis))) restore_perm = np.hstack((dims[1:axis+1], [0], dims[axis+1:])) indices = tf.cast(tf.floor(tf.range(0, shape[axis]*repeats)/tf.constant(repeats)), 'int32') shuffled = tf.transpose(tensor, prepare_perm) repeated = tf.gather(shuffled, indices) return tf.transpose(repeated, restore_perm)
def test_uw_rgbd_scene(version='v1'): from pybot.vision.image_utils import to_color from pybot.vision.imshow_utils import imshow_cv v1_directory = '/media/spillai/MRG-HD1/data/rgbd-scenes-v1/' v2_directory = '/media/spillai/MRG-HD1/data/rgbd-scenes-v2/rgbd-scenes-v2/' if version == 'v1': rgbd_data_uw = UWRGBDSceneDataset(version='v1', directory=os.path.join(v1_directory, 'rgbd-scenes'), aligned_directory=os.path.join(v1_directory, 'rgbd-scenes-aligned')) elif version == 'v2': rgbd_data_uw = UWRGBDSceneDataset(version='v2', directory=v2_directory) else: raise RuntimeError('''Version %s not supported. ''' '''Check dataset and choose v1/v2 scene dataset''' % version) for f in rgbd_data_uw.iteritems(every_k_frames=5, with_ground_truth=True): vis = rgbd_data_uw.annotate(f) imshow_cv('frame', np.hstack([f.img, vis]), text='Image') imshow_cv('depth', (f.depth / 16).astype(np.uint8), text='Depth') cv2.waitKey(100) return rgbd_data_uw
def __mul__(self, other): """ Left-multiply RigidTransform with another rigid transform Two variants: RigidTransform: Identical to oplus operation ndarray: transform [N x 3] point set (X_2 = p_21 * X_1) """ if isinstance(other, DualQuaternion): return DualQuaternion.from_dq(other.real * self.real, other.dual * self.real + other.real * self.dual) elif isinstance(other, float): return DualQuaternion.from_dq(self.real * other, self.dual * other) # elif isinstance(other, nd.array): # X = np.hstack([other, np.ones((len(other),1))]).T # return (np.dot(self.matrix, X).T)[:,:3] else: raise TypeError('__mul__ typeerror {:}'.format(type(other)))
def im_describe(*args, **kwargs): """ Describe image using dense sampling / specific detector-descriptor combination. Sugar for description-only call. """ kpts, desc = im_detect_and_describe(*args, **kwargs) return desc # def color_codes(img, kpts): # # Extract color information (Lab) # pts = np.vstack([kp.pt for kp in kpts]).astype(np.int32) # imgc = median_blur(img, size=5) # cdesc = img[pts[:,1], pts[:,0]] # return kpts, np.hstack([desc, cdesc]) # ===================================================================== # General-purpose object recognition interfaces, and functions # ---------------------------------------------------------------------
def ray(self, pts, undistort=True, rotate=False, normalize=False): """ Returns the ray corresponding to the points. Optionally undistort (defaults to true), and rotate ray to the camera's viewpoint """ upts = self.undistort_points(pts) if undistort else pts ret = unproject_points( np.hstack([ (colvec(upts[:,0])-self.cx) / self.fx, (colvec(upts[:,1])-self.cy) / self.fy ]) ) if rotate: ret = self.extrinsics.rotate_vec(ret) if normalize: ret = ret / np.linalg.norm(ret, axis=1)[:, np.newaxis] return ret
def train_linear_regression(X_train, y_train, max_iter, learning_rate, fit_intercept=False): """ Train a linear regression model with gradient descent Args: X_train, y_train (numpy.ndarray, training data set) max_iter (int, number of iterations) learning_rate (float) fit_intercept (bool, with an intercept w0 or not) Returns: numpy.ndarray, learned weights """ if fit_intercept: intercept = np.ones((X_train.shape[0], 1)) X_train = np.hstack((intercept, X_train)) weights = np.zeros(X_train.shape[1]) for iteration in range(max_iter): weights = update_weights_gd(X_train, y_train, weights, learning_rate) # Check the cost for every 100 (for example) iterations if iteration % 100 == 0: print(compute_cost(X_train, y_train, weights)) return weights
def train_logistic_regression(X_train, y_train, max_iter, learning_rate, fit_intercept=False): """ Train a logistic regression model Args: X_train, y_train (numpy.ndarray, training data set) max_iter (int, number of iterations) learning_rate (float) fit_intercept (bool, with an intercept w0 or not) Returns: numpy.ndarray, learned weights """ if fit_intercept: intercept = np.ones((X_train.shape[0], 1)) X_train = np.hstack((intercept, X_train)) weights = np.zeros(X_train.shape[1]) for iteration in range(max_iter): weights = update_weights_gd(X_train, y_train, weights, learning_rate) # Check the cost for every 100 (for example) iterations if iteration % 1000 == 0: print(compute_cost(X_train, y_train, weights)) return weights
def train_logistic_regression(X_train, y_train, max_iter, learning_rate, fit_intercept=False): """ Train a logistic regression model Args: X_train, y_train (numpy.ndarray, training data set) max_iter (int, number of iterations) learning_rate (float) fit_intercept (bool, with an intercept w0 or not) Returns: numpy.ndarray, learned weights """ if fit_intercept: intercept = np.ones((X_train.shape[0], 1)) X_train = np.hstack((intercept, X_train)) weights = np.zeros(X_train.shape[1]) for iteration in range(max_iter): weights = update_weights_sgd(X_train, y_train, weights, learning_rate) # Check the cost for every 2 (for example) iterations if iteration % 2 == 0: print(compute_cost(X_train, y_train, weights)) return weights # Train the SGD model based on 10000 samples
def initwithsize(self, curshape, dim): # DIM-dependent initialization if self.dim != dim: if self.zerox: self.xopt = zeros(dim) else: self.xopt = compute_xopt(self.rseed, dim) scale = max(1, dim ** .5 / 8.) # nota: different from scales in F8 self.linearTF = scale * compute_rotation(self.rseed, dim) self.xopt = np.hstack(dot(.5 * np.ones((1, dim)), self.linearTF.T)) / scale ** 2 # DIM- and POPSI-dependent initialisations of DIM*POPSI matrices if self.lastshape != curshape: self.dim = dim self.lastshape = curshape self.arrxopt = resize(self.xopt, curshape)
def initwithsize(self, curshape, dim): # DIM-dependent initialization if self.dim != dim: scale = max(1, dim ** .5 / 8.) self.linearTF = scale * compute_rotation(self.rseed, dim) # if self.zerox: # self.xopt = zeros(dim) # does not work here # else: # TODO: clean this line self.xopt = np.hstack(dot(self.linearTF, 0.5 * np.ones((dim, 1)) / scale ** 2)) # DIM- and POPSI-dependent initialisations of DIM*POPSI matrices if self.lastshape != curshape: self.dim = dim self.lastshape = curshape self.arrxopt = resize(self.xopt, curshape)
def modeFilter(data, window=500, step=None, bins=None): """Filter based on histogram-based mode function""" d1 = data.view(np.ndarray) vals = [] l2 = int(window/2.) if step is None: step = l2 i = 0 while True: if i > len(data)-step: break vals.append(mode(d1[i:i+window], bins)) i += step chunks = [np.linspace(vals[0], vals[0], l2)] for i in range(len(vals)-1): chunks.append(np.linspace(vals[i], vals[i+1], step)) remain = len(data) - step*(len(vals)-1) - l2 chunks.append(np.linspace(vals[-1], vals[-1], remain)) d2 = np.hstack(chunks) if (hasattr(data, 'implements') and data.implements('MetaArray')): return MetaArray(d2, info=data.infoCopy()) return d2
def __loadChnTimeWave(self,f,selectChan): times = list() waveforms = list() spk_startswith = "spike_{0}".format(selectChan) for chn_unit in f["spikes"].keys(): if chn_unit.startswith(spk_startswith): time = f["spikes"][chn_unit]["times"].value waveform = f["spikes"][chn_unit]["waveforms"].value times.append(time) waveforms.append(waveform) if times: times = np.hstack(times) waveforms = np.vstack(waveforms) sort_index = np.argsort(times) waveforms = waveforms[sort_index] times = times[sort_index] return times,waveforms else: return None,None
def __load_waveforms(self,selectChan,file_name): spk_startswith = "spike_{0}".format(selectChan) with hp.File(file_name,"r") as f: times = list() waveforms = list() for chn_unit in f["spikes"].keys(): if chn_unit.startswith(spk_startswith): tep_time = f["spikes"][chn_unit]["times"].value waveform = f["spikes"][chn_unit]["waveforms"].value times.append(tep_time) waveforms.append(waveform) if times: times = np.hstack(times) waveforms = np.vstack(waveforms) sort_index = np.argsort(times) waveforms = waveforms[sort_index] return waveforms else: return None
def __test_ks(self,x): x = x[~np.isnan(x)] n = x.size x.sort() yCDF = np.arange(1,n+1)/float(n) notdup = np.hstack([np.diff(x,1),[1]]) notdup = notdup>0 x_expcdf = x[notdup] y_expcdf = np.hstack([[0],yCDF[notdup]]) zScores = (x_expcdf-np.mean(x))/np.std(x,ddof=1); mu = 0 sigma = 1 theocdf = 0.5*erfc(-(zScores-mu)/(np.sqrt(2)*sigma)) delta1 = y_expcdf[:-1]-theocdf delta2 = y_expcdf[1:]-theocdf deltacdf = np.abs(np.hstack([delta1,delta2])) KSmax = deltacdf.max() return KSmax
def parse_audio_files(parent_dir,sub_dirs,file_ext='*.wav'): ignored = 0 features, labels, name = np.empty((0,161)), np.empty(0), np.empty(0) for label, sub_dir in enumerate(sub_dirs): print sub_dir for fn in glob.glob(os.path.join(parent_dir, sub_dir, file_ext)): try: mfccs, chroma, mel, contrast, tonnetz = extract_features(fn) ext_features = np.hstack([mfccs, chroma, mel, contrast, tonnetz]) features = np.vstack([features,ext_features]) l = [fn.split('-')[1]] * (mfccs.shape[0]) labels = np.append(labels, l) except (KeyboardInterrupt, SystemExit): raise except: ignored += 1 print "Ignored files: ", ignored return np.array(features), np.array(labels, dtype = np.int)
def _get_rois_blob(im_rois, im_scale_factors): """Converts RoIs into network inputs. Arguments: im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates im_scale_factors (list): scale factors as returned by _get_image_blob Returns: blob (ndarray): R x 5 matrix of RoIs in the image pyramid """ rois_blob_real = [] for i in xrange(len(im_scale_factors)): rois, levels = _project_im_rois(im_rois, np.array([im_scale_factors[i]])) rois_blob = np.hstack((levels, rois)) rois_blob_real.append(rois_blob.astype(np.float32, copy=False)) return rois_blob_real
def _makeflat(self, start=None, end=None, groups = False): eeg = list() for sub in self.data[start:end]: if len(sub) % self.chunk_len == 0: eeg.append(sub.reshape([-1, self.chunk_len,3])) else: print('ERROR: Please choose a chunk length that is a factor of {}. Current len = {}'.format(self.samples_per_epoch, len(sub))) return [0,0] hypno = list() group = list() hypno_repeat = self.samples_per_epoch / self.chunk_len idx = 0 for sub in self.hypno[start:end]: hypno.append(np.repeat(sub, hypno_repeat)) group.append(np.repeat(idx, len(hypno[-1]))) idx += 1 if groups: return np.vstack(eeg), np.hstack(hypno), np.hstack(group) else: return np.vstack(eeg), np.hstack(hypno)
def get_all_features_m(data): """ returns a vector with extraced features :param data: datapoints x samples x dimensions (dimensions: EEG,EMG, EOG) """ p = Pool(3) t1 = p.apply_async(feat_eeg,(data[:,:,0],)) t2 = p.apply_async(feat_eog,(data[:,:,1],)) t3 = p.apply_async(feat_emg,(data[:,:,2],)) eeg = t1.get(timeout = 1200) eog = t2.get(timeout = 1200) emg = t3.get(timeout = 1200) p.close() p.join() return np.hstack([eeg,emg,eog])
def feat_ann(c=0): batch_size =700 feats_eeg = scipy.stats.zscore(tools.feat_eeg(data[:,:,0])) feats_emg = scipy.stats.zscore(tools.feat_emg(data[:,:,1])) feats_eog = scipy.stats.zscore(tools.feat_eog(data[:,:,2])) feats_all = np.hstack([feats_eeg, feats_emg, feats_eog]) results = dict() r = cv(feats_eeg, target, groups, models.ann, name = 'eeg', stop_after=15,batch_size=batch_size, counter=c, plot=plot) results.update(r) r = cv(np.hstack([feats_eeg,feats_eog]), target, groups, models.ann, name = 'eeg+eog',batch_size=batch_size, stop_after=15, counter=c, plot=plot) results.update(r) r = cv(np.hstack([feats_eeg,feats_emg]), target, groups, models.ann, name = 'eeg+emg',batch_size=batch_size, stop_after=15, counter=c, plot=plot) results.update(r) r = cv(feats_all, target, groups, models.ann, name = 'all',batch_size=batch_size, stop_after=15, counter=c, plot=plot) results.update(r) with open('results_electrodes_feat.pkl', 'wb') as f: pickle.dump(results, f)
def rotation_from_axes(x_axis, y_axis, z_axis): """Convert specification of axis in target frame to a rotation matrix from source to target frame. Parameters ---------- x_axis : :obj:`numpy.ndarray` of float A normalized 3-vector for the target frame's x-axis. y_axis : :obj:`numpy.ndarray` of float A normalized 3-vector for the target frame's y-axis. z_axis : :obj:`numpy.ndarray` of float A normalized 3-vector for the target frame's z-axis. Returns ------- :obj:`numpy.ndarray` of float A 3x3 rotation matrix that transforms from a source frame to the given target frame. """ return np.hstack((x_axis[:,np.newaxis], y_axis[:,np.newaxis], z_axis[:,np.newaxis]))
def online_em(self, new_labels, w = 0.1, num_it = 3, no_train = False): if len(new_labels) == 0: return n = self.lc.n l = len(new_labels) self.lc.add_labels(new_labels, l * [None]) self.N = self.lc.n self.qz = np.hstack((self.qz, np.zeros(l))) self.maj_lab = np.hstack((self.maj_lab, np.zeros(l))) self.init_prob(id_range = (n, self.lc.n)) if no_train: return self.m_step(id_range = (n, self.lc.n), w = w) for it in range(num_it): self.e_step(id_range = (n, self.lc.n), w = w) self.m_step(id_range = (n, self.lc.n), w = w)
def compute_pvalue(self, samples): samples = self._make_two_dimensional(samples) self.shape = samples.shape[1] stein_statistics = [] for f in range(self.number_of_random_frequencies): # This is a little bit of a bug , but th holds even for this choice random_frequency = np.random.randn() matrix_of_stats = self.stein_stat(random_frequency=random_frequency, samples=samples) stein_statistics.append(matrix_of_stats) normal_under_null = np.hstack(stein_statistics) normal_under_null = self._make_two_dimensional(normal_under_null) return mahalanobis_distance(normal_under_null, normal_under_null.shape[1])
def plotJoints(self, ax, joint, color='nice', jcolor=None): """ Plot connected joints :type ax: axis to plot on :type joint: joints to connect :type color: line color """ color_index = 0 for i in range(joint.shape[0]): ax.scatter(joint[i, 0], joint[i, 1], c=(self.jointcolors[color_index % len(self.jointcolors)] if jcolor is None else jcolor), marker='.', s=400) color_index += 1 for i in range(len(self.jointConnections)): ax.plot(numpy.hstack((joint[self.jointConnections[i][0], 0], joint[self.jointConnections[i][1], 0])), numpy.hstack((joint[self.jointConnections[i][0], 1], joint[self.jointConnections[i][1], 1])), c=(color if color is not 'nice' else self.jointConnectionColors[i]), linewidth=2.0)
def arma_predictor_model(x, y, m, n): """ Return matrix and vector relating (*m*, *n*) ARMA model to the input *x* and output *y*. In other words, construct the max(*m*, *n*) - 1 by (*m* - 1 + *n* - 1) matrix A such that y[k] + a_1 y[k - 1] + ... + a_m y[k - m] = b_1 x[k - 1] + ... + b_n x[k - n] and the vector b corresponds to y[k] for k >= max(*m*, *n*). """ assert len(x) == len(y) k = max(m, n) A1 = SP.linalg.toeplitz(-y[k:-1], r=-y[(k - m):k][::-1]) A2 = SP.linalg.toeplitz(x[k:-1], r=x[(k - n):k][::-1]) A = NP.hstack((A1, A2)) b = y[k+1:] return A, b
def tensor_vstack(tensor_list, pad=0): """ vertically stack tensors :param tensor_list: list of tensor to be stacked vertically :param pad: label to pad with :return: tensor with max shape """ ndim = len(tensor_list[0].shape) if ndim == 1: return np.hstack(tensor_list) dimensions = [0] for dim in range(1, ndim): dimensions.append(max([tensor.shape[dim] for tensor in tensor_list])) for ind, tensor in enumerate(tensor_list): pad_shape = [(0, 0)] for dim in range(1, ndim): pad_shape.append((0, dimensions[dim] - tensor.shape[dim])) tensor_list[ind] = np.lib.pad(tensor, pad_shape, 'constant', constant_values=pad) all_tensor = np.vstack(tensor_list) return all_tensor
def reset(self): self.cur = 0 if self.shuffle: if config.TRAIN.ASPECT_GROUPING: widths = np.array([r['width'] for r in self.roidb]) heights = np.array([r['height'] for r in self.roidb]) horz = (widths >= heights) vert = np.logical_not(horz) horz_inds = np.where(horz)[0] vert_inds = np.where(vert)[0] inds = np.hstack((np.random.permutation(horz_inds), np.random.permutation(vert_inds))) if inds.shape[0] % 2: inds_ = np.reshape(inds[:-1], (-1, 2)) row_perm = np.random.permutation(np.arange(inds_.shape[0])) inds[:-1] = np.reshape(inds_[row_perm, :], (-1, )) else: inds = np.reshape(inds, (-1, 2)) row_perm = np.random.permutation(np.arange(inds.shape[0])) inds = np.reshape(inds[row_perm, :], (-1, )) self.index = inds else: np.random.shuffle(self.index)
def _shuffle_roidb_inds(self): """Randomly permute the training roidb.""" if cfg.TRAIN.ASPECT_GROUPING: widths = np.array([r['width'] for r in self._roidb]) heights = np.array([r['height'] for r in self._roidb]) horz = (widths >= heights) vert = np.logical_not(horz) horz_inds = np.where(horz)[0] vert_inds = np.where(vert)[0] inds = np.hstack(( np.random.permutation(horz_inds), np.random.permutation(vert_inds))) inds = np.reshape(inds, (-1, 2)) row_perm = np.random.permutation(np.arange(inds.shape[0])) inds = np.reshape(inds[row_perm, :], (-1,)) self._perm = inds else: self._perm = np.random.permutation(np.arange(len(self._roidb))) self._cur = 0
def imdb_proposals(net, imdb): """Generate RPN proposals on all images in an imdb.""" _t = Timer() imdb_boxes = [[] for _ in xrange(imdb.num_images)] for i in xrange(imdb.num_images): im = cv2.imread(imdb.image_path_at(i)) _t.tic() imdb_boxes[i], scores = im_proposals(net, im) _t.toc() print 'im_proposals: {:d}/{:d} {:.3f}s' \ .format(i + 1, imdb.num_images, _t.average_time) if 0: dets = np.hstack((imdb_boxes[i], scores)) # from IPython import embed; embed() _vis_proposals(im, dets[:3, :], thresh=0.9) plt.show() return imdb_boxes
def circumcenter(self, tri): """Compute circumcenter and circumradius of a triangle in 2D. Uses an extension of the method described here: http://www.ics.uci.edu/~eppstein/junkyard/circumcenter.html """ pts = np.asarray([self.coords[v] for v in tri]) pts2 = np.dot(pts, pts.T) A = np.bmat([[2 * pts2, [[1], [1], [1]]], [[[1, 1, 1, 0]]]]) b = np.hstack((np.sum(pts * pts, axis=1), [1])) x = np.linalg.solve(A, b) bary_coords = x[:-1] center = np.dot(bary_coords, pts) # radius = np.linalg.norm(pts[0] - center) # euclidean distance radius = np.sum(np.square(pts[0] - center)) # squared distance return (center, radius)
def test_matrices_l_h_after_func_fill(self, qpOASES_mat_fixtures): """ Verify qpOASES matrices after filling. """ pcs, pp = qpOASES_mat_fixtures random_fill([pp.l, pp.h]) pp._fill_matrices() for i in range(pp.N+1): assert pp.l[i, 0] == -INFTY assert pp.l[i, 1] == 0 assert pp.h[i, 0] == INFTY assert pp.h[i, 1] == INFTY l_expected = np.hstack(map(lambda pc: pc.l[i], pcs)) h_expected = np.hstack(map(lambda pc: pc.h[i], pcs)) assert np.allclose(pp.l[i, 2:], l_expected) assert np.allclose(pp.h[i, 2:], h_expected)
def test_canonical_mat(self, intp_fixture): """ """ pc, pc_intp = intp_fixture # number for i in range(pc_intp.N): ds = pc_intp.ss[i+1] - pc_intp.ss[i] ai_new = np.hstack(( pc.a[i], pc.a[i+1] + 2 * ds * pc.b[i+1])) bi_new = np.hstack((pc.b[i], pc.b[i+1])) ci_new = np.hstack((pc.c[i], pc.c[i+1])) assert np.allclose(ai_new, pc_intp.a[i]) assert np.allclose(bi_new, pc_intp.b[i]) assert np.allclose(ci_new, pc_intp.c[i])
def test_equality_mat(self, intp_fixture): """ Equality constraint: abar, bbar, cbar, D """ pc, pc_intp = intp_fixture # number for i in range(pc_intp.N): ds = pc_intp.ss[i+1] - pc_intp.ss[i] ai_new = np.hstack(( pc.abar[i], pc.abar[i+1] + 2 * ds * pc.bbar[i+1])) bi_new = np.hstack((pc.bbar[i], pc.bbar[i+1])) ci_new = np.hstack((pc.cbar[i], pc.cbar[i+1])) Di_new = block_diag(pc.D[i], pc.D[i+1]) li_new = np.hstack((pc.l[i], pc.l[i+1])) hi_new = np.hstack((pc.h[i], pc.h[i+1])) assert np.allclose(ai_new, pc_intp.abar[i]) assert np.allclose(bi_new, pc_intp.bbar[i]) assert np.allclose(ci_new, pc_intp.cbar[i]) assert np.allclose(Di_new, pc_intp.D[i], atol=1e-8) assert np.allclose(li_new, pc_intp.l[i]) assert np.allclose(hi_new, pc_intp.h[i])
def plotFields(layer,fieldShape=None,channel=None,figOffset=1,cmap=None,padding=0.01): # Receptive Fields Summary try: W = layer.W except: W = layer wp = W.eval().transpose(); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape fields = np.reshape(wp,list(wp.shape[0:-1])+fieldShape) else: # Convolutional layer already has shape features, channels, iy, ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) perRow = int(math.floor(math.sqrt(fields.shape[0]))) perColumn = int(math.ceil(fields.shape[0]/float(perRow))) fig = mpl.figure(figOffset); mpl.clf() # Using image grid from mpl_toolkits.axes_grid1 import ImageGrid grid = ImageGrid(fig,111,nrows_ncols=(perRow,perColumn),axes_pad=padding,cbar_mode='single') for i in range(0,np.shape(fields)[0]): im = grid[i].imshow(fields[i],cmap=cmap); grid.cbar_axes[0].colorbar(im) mpl.title('%s Receptive Fields' % layer.name) # old way # fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) # tiled = [] # for i in range(0,perColumn*perRow,perColumn): # tiled.append(np.hstack(fields2[i:i+perColumn])) # # tiled = np.vstack(tiled) # mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Receptive Fields' % layer.name); mpl.colorbar(); mpl.figure(figOffset+1); mpl.clf(); mpl.imshow(np.sum(np.abs(fields),0),cmap=cmap); mpl.title('%s Total Absolute Input Dependency' % layer.name); mpl.colorbar()
def plotOutput(layer,feed_dict,fieldShape=None,channel=None,figOffset=1,cmap=None): # Output summary try: W = layer.output except: W = layer wp = W.eval(feed_dict=feed_dict); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape temp = np.zeros(np.product(fieldShape)); temp[0:np.shape(wp.ravel())[0]] = wp.ravel() fields = np.reshape(temp,[1]+fieldShape) else: # Convolutional layer already has shape wp = np.rollaxis(wp,3,0) features, channels, iy,ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) perRow = int(math.floor(math.sqrt(fields.shape[0]))) perColumn = int(math.ceil(fields.shape[0]/float(perRow))) fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) tiled = [] for i in range(0,perColumn*perRow,perColumn): tiled.append(np.hstack(fields2[i:i+perColumn])) tiled = np.vstack(tiled) if figOffset is not None: mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Output' % layer.name); mpl.colorbar();
def plotFields(layer,fieldShape=None,channel=None,maxFields=25,figName='ReceptiveFields',cmap=None,padding=0.01): # Receptive Fields Summary W = layer.W wp = W.eval().transpose(); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape fields = np.reshape(wp,list(wp.shape[0:-1])+fieldShape) else: # Convolutional layer already has shape features, channels, iy, ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) fieldsN = min(fields.shape[0],maxFields) perRow = int(math.floor(math.sqrt(fieldsN))) perColumn = int(math.ceil(fieldsN/float(perRow))) fig = mpl.figure(figName); mpl.clf() # Using image grid from mpl_toolkits.axes_grid1 import ImageGrid grid = ImageGrid(fig,111,nrows_ncols=(perRow,perColumn),axes_pad=padding,cbar_mode='single') for i in range(0,fieldsN): im = grid[i].imshow(fields[i],cmap=cmap); grid.cbar_axes[0].colorbar(im) mpl.title('%s Receptive Fields' % layer.name) # old way # fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) # tiled = [] # for i in range(0,perColumn*perRow,perColumn): # tiled.append(np.hstack(fields2[i:i+perColumn])) # # tiled = np.vstack(tiled) # mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Receptive Fields' % layer.name); mpl.colorbar(); mpl.figure(figName+' Total'); mpl.clf(); mpl.imshow(np.sum(np.abs(fields),0),cmap=cmap); mpl.title('%s Total Absolute Input Dependency' % layer.name); mpl.colorbar()
