Python numpy.r_() Examples
The following are 30
code examples of numpy.r_().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: DataModule.py From sgd-influence with MIT License | 8 votes |
def load(self): categories = ['comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware'] newsgroups_train = fetch_20newsgroups( subset='train', remove=('headers', 'footers', 'quotes'), categories=categories) newsgroups_test = fetch_20newsgroups( subset='test', remove=('headers', 'footers', 'quotes'), categories=categories) vectorizer = TfidfVectorizer(stop_words='english', min_df=0.001, max_df=0.20) vectors = vectorizer.fit_transform(newsgroups_train.data) vectors_test = vectorizer.transform(newsgroups_test.data) x1 = vectors y1 = newsgroups_train.target x2 = vectors_test y2 = newsgroups_test.target x = np.array(np.r_[x1.todense(), x2.todense()]) y = np.r_[y1, y2] return x, y
Example #2
Source File: test_utils.py From recruit with Apache License 2.0 | 6 votes |
def test_complex128_pass(self): nulp = 5 x = np.linspace(-20, 20, 50, dtype=np.float64) x = 10**x x = np.r_[-x, x] xi = x + x*1j eps = np.finfo(x.dtype).eps y = x + x*eps*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) # The test condition needs to be at least a factor of sqrt(2) smaller # because the real and imaginary parts both change y = x + x*eps*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp) epsneg = np.finfo(x.dtype).epsneg y = x - x*epsneg*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x - x*epsneg*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
Example #3
Source File: reader.py From buzzard with Apache License 2.0 | 6 votes |
def _create_work_job(self, qi, prod_idx, cache_fp, path): if prod_idx not in self._sample_array_per_prod_tile[qi]: # Allocate sample array # If no interpolation or nodata conversion is necessary, this is the array that will be # returned in the output queue full_sample_fp = qi.prod[prod_idx].sample_fp self._sample_array_per_prod_tile[qi][prod_idx] = np.empty( np.r_[full_sample_fp.shape, len(qi.unique_channel_ids)], self._raster.dtype, ) self._raster.debug_mngr.event( 'object_allocated', self._sample_array_per_prod_tile[qi][prod_idx] ) self._missing_cache_fps_per_prod_tile[qi][prod_idx] = set(qi.prod[prod_idx].cache_fps) dst_array = self._sample_array_per_prod_tile[qi][prod_idx] return Work(self, qi, prod_idx, cache_fp, path, dst_array)
Example #4
Source File: simplest_raster_plot.py From ibllib with MIT License | 6 votes |
def raster_complete(R, times, Clusters): ''' Plot a rasterplot for the complete recording (might be slow, restrict R if so), ordered by insertion depth ''' plt.imshow(R, aspect='auto', cmap='binary', vmax=T_BIN / 0.001 / 4, origin='lower', extent=np.r_[times[[0, -1]], Clusters[[0, -1]]]) plt.xlabel('Time (s)') plt.ylabel('Cluster #; ordered by depth') plt.show() # plt.savefig('/home/mic/Rasters/%s.svg' %(trial_number)) # plt.close('all') plt.tight_layout()
Example #5
Source File: ephys_fpga.py From ibllib with MIT License | 6 votes |
def _audio_events_extraction(audio_t, audio_fronts): """ From detected fronts on the audio sync traces, outputs the synchronisation events related to tone in :param audio_t: numpy vector containing times of fronts :param audio_fronts: numpy vector containing polarity of fronts (1 rise, -1 fall) :return: numpy arrays t_ready_tone_in, t_error_tone_in """ # make sure that there are no 2 consecutive fall or consecutive rise events assert(np.all(np.abs(np.diff(audio_fronts)) == 2)) # take only even time differences: ie. from rising to falling fronts dt = np.diff(audio_t)[::2] # detect ready tone by length below 110 ms i_ready_tone_in = np.r_[np.where(dt <= 0.11)[0] * 2] t_ready_tone_in = audio_t[i_ready_tone_in] # error tones are events lasting from 400ms to 600ms i_error_tone_in = np.where(np.logical_and(0.4 < dt, dt < 1.2))[0] * 2 t_error_tone_in = audio_t[i_error_tone_in] return t_ready_tone_in, t_error_tone_in
Example #6
Source File: kaldi_io.py From Attentive-Filtering-Network with MIT License | 6 votes |
def read_segments_as_bool_vec(segments_file): """ [ bool_vec ] = read_segments_as_bool_vec(segments_file) using kaldi 'segments' file for 1 wav, format : '<utt> <rec> <t-beg> <t-end>' - t-beg, t-end is in seconds, - assumed 100 frames/second, """ segs = np.loadtxt(segments_file, dtype='object,object,f,f', ndmin=1) # Sanity checks, assert(len(segs) > 0) # empty segmentation is an error, assert(len(np.unique([rec[1] for rec in segs ])) == 1) # segments with only 1 wav-file, # Convert time to frame-indexes, start = np.rint([100 * rec[2] for rec in segs]).astype(int) end = np.rint([100 * rec[3] for rec in segs]).astype(int) # Taken from 'read_lab_to_bool_vec', htk.py, frms = np.repeat(np.r_[np.tile([False,True], len(end)), False], np.r_[np.c_[start - np.r_[0, end[:-1]], end-start].flat, 0]) assert np.sum(end-start) == np.sum(frms) return frms
Example #7
Source File: test_utils.py From recruit with Apache License 2.0 | 6 votes |
def test_float64_pass(self): # The number of units of least precision # In this case, use a few places above the lowest level (ie nulp=1) nulp = 5 x = np.linspace(-20, 20, 50, dtype=np.float64) x = 10**x x = np.r_[-x, x] # Addition eps = np.finfo(x.dtype).eps y = x + x*eps*nulp/2. assert_array_almost_equal_nulp(x, y, nulp) # Subtraction epsneg = np.finfo(x.dtype).epsneg y = x - x*epsneg*nulp/2. assert_array_almost_equal_nulp(x, y, nulp)
Example #8
Source File: build_dataset.py From hgru4rec with MIT License | 6 votes |
def make_sessions(data, session_th=30 * 60, is_ordered=False, user_key='user_id', item_key='item_id', time_key='ts'): """Assigns session ids to the events in data without grouping keys""" if not is_ordered: # sort data by user and time data.sort_values(by=[user_key, time_key], ascending=True, inplace=True) # compute the time difference between queries tdiff = np.diff(data[time_key].values) # check which of them are bigger then session_th split_session = tdiff > session_th split_session = np.r_[True, split_session] # check when the user chenges is data new_user = data['user_id'].values[1:] != data['user_id'].values[:-1] new_user = np.r_[True, new_user] # a new sessions stars when at least one of the two conditions is verified new_session = np.logical_or(new_user, split_session) # compute the session ids session_ids = np.cumsum(new_session) data['session_id'] = session_ids return data
Example #9
Source File: _a_gdal_raster.py From buzzard with Apache License 2.0 | 6 votes |
def sample_bands_driver(self, fp, channel_ids, gdal_ds): rtlx, rtly = self.fp.spatial_to_raster(fp.tl) assert rtlx >= 0 and rtlx < self.fp.rsizex, '{} >= 0 and {} < {}'.format(rtlx, rtlx, self.fp.rsizex) assert rtly >= 0 and rtly < self.fp.rsizey, '{} >= 0 and {} < {}'.format(rtly, rtly, self.fp.rsizey) dstarray = np.empty(np.r_[fp.shape, len(channel_ids)], self.dtype) for i, channel_id in enumerate(channel_ids): gdal_band = gdal_ds.GetRasterBand(channel_id + 1) success, payload = GDALErrorCatcher(gdal_band.ReadAsArray, none_is_error=True)( int(rtlx), int(rtly), int(fp.rsizex), int(fp.rsizey), buf_obj=dstarray[..., i], ) if not success: # pragma: no cover raise ValueError('Could not read array (gdal error: `{}`)'.format( payload[1] )) return dstarray # set_data implementation ******************************************************************* **
Example #10
Source File: __init__.py From typhon with MIT License | 6 votes |
def trapz_inte_edge(y, x): """ Trapezoidal integration including edge grids Parameters: y: Array of y-axis value x: Array of x-axis value Returns: Area corresponded to each y (or x) value For Example, Area corresponded to at y_n is ..math: 0.5*y_n ((x_{n} - x_{n-1}) + (x_{n+1} - x_{n})) Area corresponded to at y_0 (start point(edge)) is ..math: 0.5*y_0(x_{1} - x_{0}) """ weight_x_0 = 0.5 * (x[1] - x[0]) weight_x_f = 0.5 * (x[-1] - x[-2]) weight_x_n = 0.5 * (x[1:-1] - x[:-2]) + 0.5 * (x[2:] - x[1:-1]) weight_x = np.r_[weight_x_0, weight_x_n, weight_x_f] return weight_x*y
Example #11
Source File: _a_gdal_raster.py From buzzard with Apache License 2.0 | 6 votes |
def get_data(self, fp, channel_ids, dst_nodata, interpolation): samplefp = self.build_sampling_footprint(fp, interpolation) if samplefp is None: return np.full( np.r_[fp.shape, len(channel_ids)], dst_nodata, self.dtype ) with self.acquire_driver_object() as gdal_ds: array = self.sample_bands_driver(samplefp, channel_ids, gdal_ds) array = self.remap( samplefp, fp, array=array, mask=None, src_nodata=self.nodata, dst_nodata=dst_nodata, mask_mode='erode', interpolation=interpolation, ) array = array.astype(self.dtype, copy=False) return array
Example #12
Source File: test_utils.py From recruit with Apache License 2.0 | 6 votes |
def test_complex64_pass(self): nulp = 5 x = np.linspace(-20, 20, 50, dtype=np.float32) x = 10**x x = np.r_[-x, x] xi = x + x*1j eps = np.finfo(x.dtype).eps y = x + x*eps*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x + x*eps*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp) epsneg = np.finfo(x.dtype).epsneg y = x - x*epsneg*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x - x*epsneg*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
Example #13
Source File: test_f0stats.py From sprocket with MIT License | 6 votes |
def test_estimate_F0statistics(self): f0stats = F0statistics() orgf0s = [] for i in range(1, 4): orgf0s.append(200 * np.r_[np.random.rand(100 * i), np.zeros(100)]) orgf0stats = f0stats.estimate(orgf0s) tarf0s = [] for i in range(1, 8): tarf0s.append(300 * np.r_[np.random.rand(100 * i), np.zeros(100)]) tarf0stats = f0stats.estimate(tarf0s) orgf0 = 200 * np.r_[np.random.rand(100 * i), np.zeros(100)] cvf0 = f0stats.convert(orgf0, orgf0stats, tarf0stats) assert len(orgf0) == len(cvf0)
Example #14
Source File: utils.py From contextualbandits with BSD 2-Clause "Simplified" License | 6 votes |
def get_batch(self, X, y): if self.curr == 0: self.add_obs(X, y) return X, y if (self.curr < self.n) and (isinstance(self.X_reserve, list)): if not self.has_sparse: old_X = np.concatenate(self.X_reserve, axis=0) else: old_X = sp_vstack(self.X_reserve) old_y = np.concatenate(self.y_reserve, axis=0) else: old_X = self.X_reserve[:self.curr].copy() old_y = self.y_reserve[:self.curr].copy() if X.shape[0] == 0: return old_X, old_y else: self.add_obs(X, y) if not issparse(old_X) and not issparse(X): return np.r_[old_X, X], np.r_[old_y, y] else: return sp_vstack([old_X, X]), np.r_[old_y, y]
Example #15
Source File: _footprint.py From buzzard with Apache License 2.0 | 6 votes |
def extent(self): """Get the Footprint's extent (`x` then `y`) Example ------- >>> minx, maxx, miny, maxy = fp.extent >>> plt.imshow(arr, extent=fp.extent) fp.extent from fp.bounds using numpy fancy indexing >>> minx, maxx, miny, maxy = fp.bounds[[0, 2, 1, 3]] """ points = np.r_["1,0,2", self.coords] return np.asarray([ points[:, 0].min(), points[:, 0].max(), points[:, 1].min(), points[:, 1].max(), ])
Example #16
Source File: _footprint.py From buzzard with Apache License 2.0 | 6 votes |
def bounds(self): """Get the Footprint's bounds (`min` then `max`) Example ------- >>> minx, miny, maxx, maxy = fp.bounds fp.bounds from fp.extent using numpy fancy indexing >>> minx, miny, maxx, maxy = fp.extent[[0, 2, 1, 3]] """ points = np.r_["1,0,2", self.coords] return np.asarray([ points[:, 0].min(), points[:, 1].min(), points[:, 0].max(), points[:, 1].max(), ])
Example #17
Source File: KMM.py From transferlearning with MIT License | 6 votes |
def fit(self, Xs, Xt): ''' Fit source and target using KMM (compute the coefficients) :param Xs: ns * dim :param Xt: nt * dim :return: Coefficients (Pt / Ps) value vector (Beta in the paper) ''' ns = Xs.shape[0] nt = Xt.shape[0] if self.eps == None: self.eps = self.B / np.sqrt(ns) K = kernel(self.kernel_type, Xs, None, self.gamma) kappa = np.sum(kernel(self.kernel_type, Xs, Xt, self.gamma) * float(ns) / float(nt), axis=1) K = matrix(K) kappa = matrix(kappa) G = matrix(np.r_[np.ones((1, ns)), -np.ones((1, ns)), np.eye(ns), -np.eye(ns)]) h = matrix(np.r_[ns * (1 + self.eps), ns * (self.eps - 1), self.B * np.ones((ns,)), np.zeros((ns,))]) sol = solvers.qp(K, -kappa, G, h) beta = np.array(sol['x']) return beta
Example #18
Source File: algorithmic.py From fine-lm with MIT License | 6 votes |
def zipf_distribution(nbr_symbols, alpha): """Helper function: Create a Zipf distribution. Args: nbr_symbols: number of symbols to use in the distribution. alpha: float, Zipf's Law Distribution parameter. Default = 1.5. Usually for modelling natural text distribution is in the range [1.1-1.6]. Returns: distr_map: list of float, Zipf's distribution over nbr_symbols. """ tmp = np.power(np.arange(1, nbr_symbols + 1), -alpha) zeta = np.r_[0.0, np.cumsum(tmp)] return [x / zeta[-1] for x in zeta]
Example #19
Source File: wsola.py From sprocket with MIT License | 5 votes |
def _search_minimum_distance(self, ref, buff): if len(ref) < self.fl: ref = np.r_[ref, np.zeros(self.fl - len(ref))] # slicing and windowing one sample by one buffmat = view_as_windows(buff, self.fl) * self.win refwin = np.array(ref * self.win).reshape(1, self.fl) corr = correlate2d(buffmat, refwin, mode='valid') return np.argmax(corr) - self.sl
Example #20
Source File: f0statistics.py From sprocket with MIT License | 5 votes |
def estimate(self, f0list): """Estimate F0 statistics from list of f0 Parameters --------- f0list : list, shape('f0num') List of several F0 sequence Returns --------- f0stats : array, shape(`[mean, std]`) Values of mean and standard deviation for logarithmic F0 """ n_files = len(f0list) for i in range(n_files): f0 = f0list[i] nonzero_indices = np.nonzero(f0) if i == 0: f0s = np.log(f0[nonzero_indices]) else: f0s = np.r_[f0s, np.log(f0[nonzero_indices])] f0stats = np.array([np.mean(f0s), np.std(f0s)]) return f0stats
Example #21
Source File: _cached_raster_recipe.py From buzzard with Apache License 2.0 | 5 votes |
def _build_cache_fps_index(self, cache_fps): idx = rtree.index.Index() bounds_inset = np.asarray([ + 1 / 4, + 1 / 4, - 1 / 4, - 1 / 4, ]) for i, fp in enumerate(cache_fps.flat): rtl = self.fp.spatial_to_raster(fp.tl, dtype=float) bounds = np.r_[rtl, rtl + fp.rsize] + bounds_inset idx.insert(i, bounds) return idx
Example #22
Source File: misc.py From sprocket with MIT License | 5 votes |
def transform_jnt(array_list): num_files = len(array_list) for i in range(num_files): if i == 0: jnt = array_list[i] else: jnt = np.r_[jnt, array_list[i]] return jnt
Example #23
Source File: emd.py From magpy with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _localmax(d): """Calculate the local maxima of a vector.""" # this gets a value of -2 if it is an unambiguous local max # value -1 denotes that the run its a part of may contain a local max diffvec = np.r_[-np.inf,d,-np.inf] diffScore=np.diff(np.sign(np.diff(diffvec))) # Run length code with help from: # http://home.online.no/~pjacklam/matlab/doc/mtt/index.html # (this is all painfully complicated, but I did it in order to avoid loops...) # here calculate the position and length of each run runEndingPositions=np.r_[np.nonzero(d[0:-1]!=d[1:])[0],len(d)-1] runLengths = np.diff(np.r_[-1, runEndingPositions]) runStarts=runEndingPositions-runLengths + 1 # Now concentrate on only the runs with length>1 realRunStarts = runStarts[runLengths>1] realRunStops = runEndingPositions[runLengths>1] realRunLengths = runLengths[runLengths>1] # save only the runs that are local maxima maxRuns=(diffScore[realRunStarts]==-1) & (diffScore[realRunStops]==-1) # If a run is a local max, then count the middle position (rounded) as the 'max' # CHECK THIS maxRunMiddles=np.round(realRunStarts[maxRuns]+realRunLengths[maxRuns]/2.)-1 # get all the maxima maxima=(diffScore==-2) maxima[maxRunMiddles.astype(np.int32)] = True return maxima #%make sure beginning & end are not local maxes #%maxima([1 end])=false;
Example #24
Source File: atlas.py From ibllib with MIT License | 5 votes |
def exit_points(self, bc): """ Given a Trajectory and a BrainCoordinates object, computes the intersection of the trajectory with the brain coordinates bounding box :param bc: BrainCoordinate objects :return: np.ndarray 2 y 3 corresponding to exit points xyz coordinates """ bounds = np.c_[bc.xlim, bc.ylim, bc.zlim] epoints = np.r_[self.eval_x(bc.xlim), self.eval_y(bc.ylim), self.eval_z(bc.zlim)] epoints = epoints[~np.all(np.isnan(epoints), axis=1)] ind = np.all(np.bitwise_and(bounds[0, :] <= epoints, epoints <= bounds[1, :]), axis=1) return epoints[ind, :]
Example #25
Source File: atlas.py From ibllib with MIT License | 5 votes |
def plot_sslice(self, ml_coordinate, volume='image', **kwargs): """ Imshow a sagittal slice :param: ml_coordinate (mm) :param: ax """ vol = self.label if volume == 'annotation' else self.image return self._plot_slice(vol[:, self.bc.x2i(ml_coordinate / 1e3), :].transpose(), extent=np.r_[self.bc.ylim * 1e3, np.flip(self.bc.zlim) * 1e3], **kwargs)
Example #26
Source File: atlas.py From ibllib with MIT License | 5 votes |
def plot_hslice(self, dv_coordinate, volume='image', **kwargs): """ Imshow a horizontal slice :param: dv_coordinate (mm) :param: ax """ vol = self.label if volume == 'annotation' else self.image return self._plot_slice(vol[:, :, self.bc.z2i(dv_coordinate / 1e3)].transpose(), extent=np.r_[self.bc.ylim * 1e3, self.bc.xlim * 1e3], **kwargs)
Example #27
Source File: atlas.py From ibllib with MIT License | 5 votes |
def plot_cslice(self, ap_coordinate, volume='image', **kwargs): """ Imshow a coronal slice :param: ap_coordinate (mm) :param: ax """ vol = self.label if volume == 'annotation' else self.image return self._plot_slice(vol[self.bc.y2i(ap_coordinate / 1e3), :, :].transpose(), extent=np.r_[self.bc.xlim * 1e3, np.flip(self.bc.zlim) * 1e3], **kwargs)
Example #28
Source File: groupby.py From recruit with Apache License 2.0 | 5 votes |
def _cumcount_array(self, ascending=True): """ Parameters ---------- ascending : bool, default True If False, number in reverse, from length of group - 1 to 0. Notes ----- this is currently implementing sort=False (though the default is sort=True) for groupby in general """ ids, _, ngroups = self.grouper.group_info sorter = get_group_index_sorter(ids, ngroups) ids, count = ids[sorter], len(ids) if count == 0: return np.empty(0, dtype=np.int64) run = np.r_[True, ids[:-1] != ids[1:]] rep = np.diff(np.r_[np.nonzero(run)[0], count]) out = (~run).cumsum() if ascending: out -= np.repeat(out[run], rep) else: out = np.repeat(out[np.r_[run[1:], True]], rep) - out rev = np.empty(count, dtype=np.intp) rev[sorter] = np.arange(count, dtype=np.intp) return out[rev].astype(np.int64, copy=False)
Example #29
Source File: test_footprint_tile_count.py From buzzard with Apache License 2.0 | 5 votes |
def assert_property_share_area(fps, tiles, tx, ty, ox, oy, param2): border_tiles = np.r_[tiles[-1, 1:-1], tiles[0, 1:-1], tiles[:, 0], tiles[:, -1]] for t in border_tiles: assert t.share_area(fps.GS)
Example #30
Source File: test_datetime_index.py From recruit with Apache License 2.0 | 5 votes |
def test_resample_group_info(n, k): # GH10914 # use a fixed seed to always have the same uniques prng = np.random.RandomState(1234) dr = date_range(start='2015-08-27', periods=n // 10, freq='T') ts = Series(prng.randint(0, n // k, n).astype('int64'), index=prng.choice(dr, n)) left = ts.resample('30T').nunique() ix = date_range(start=ts.index.min(), end=ts.index.max(), freq='30T') vals = ts.values bins = np.searchsorted(ix.values, ts.index, side='right') sorter = np.lexsort((vals, bins)) vals, bins = vals[sorter], bins[sorter] mask = np.r_[True, vals[1:] != vals[:-1]] mask |= np.r_[True, bins[1:] != bins[:-1]] arr = np.bincount(bins[mask] - 1, minlength=len(ix)).astype('int64', copy=False) right = Series(arr, index=ix) assert_series_equal(left, right)