我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.uint()。
def df_type_to_str(i): ''' Convert into simple datatypes from pandas/numpy types ''' if isinstance(i, np.bool_): return bool(i) if isinstance(i, np.int_): return int(i) if isinstance(i, np.float): if np.isnan(i): return 'NaN' elif np.isinf(i): return str(i) return float(i) if isinstance(i, np.uint): return int(i) if type(i) == bytes: return i.decode('UTF-8') if isinstance(i, (tuple, list)): return str(i) if i is pd.NaT: # not identified as a float null return 'NaN' return str(i)
def savetxt(filename, ndarray): dir = os.path.dirname(filename) if not os.path.exists(dir): os.makedirs(dir) if not os.path.isfile(filename): with open(filename, 'w') as f: labels = list(map(' '.join, np.eye(10, dtype=np.uint).astype(str))) for row in ndarray: row_str = row.astype(str) label_str = labels[row[-1]] feature_str = ' '.join(row_str[:-1]) f.write('|labels {} |features {}\n'.format(label_str, feature_str)) else: print("File already exists", filename)
def save_as_txt(filename, ndarray): dir = os.path.dirname(filename) if not os.path.exists(dir): os.makedirs(dir) if not os.path.isfile(filename): print("Saving to ", filename, end=" ") with open(filename, 'w') as f: labels = list(map(' '.join, np.eye(10, dtype=np.uint).astype(str))) for row in ndarray: row_str = row.astype(str) label_str = labels[row[-1]] feature_str = ' '.join(row_str[:-1]) f.write('|labels {} |features {}\n'.format(label_str, feature_str)) else: print("File already exists", filename)
def union_elements(elements): """elements = [(chr, s, e, id), ...], this is to join elements that have a deletion in the 'to' species """ if len(elements) < 2: return elements assert set( [e[3] for e in elements] ) == set( [elements[0][3]] ), "more than one id" el_id = elements[0][3] unioned_elements = [] for ch, chgrp in groupby(elements, key=itemgetter(0)): for (s, e) in elem_u( np.array([itemgetter(1, 2)(_) for _ in chgrp], dtype=np.uint) ): if (s < e): unioned_elements.append( (ch, s, e, el_id) ) assert len(unioned_elements) <= len(elements) return unioned_elements
def __init__(self, mean, cov, df, seed=None): """Defines the mean, co-variance and degrees of freedom a p-dimensional multivariate Student T distribution. Parameters ---------- mean: numpy.ndarray Vector containing p means, one for every dimension cov: numpy.ndarray pxp matrix containing the co-variance matrix df: np.uint Degrees of freedom """ MultiStudentT._check_parameters(mean, cov, df) self.mean = mean self.cov = cov self.df = df self.rng = np.random.RandomState(seed)
def test_predict_wrong_X_dimensions(self): rs = np.random.RandomState(1) model = RandomForestWithInstances(np.zeros((10,), dtype=np.uint), bounds=np.array( list(map(lambda x: (0, 10), range(10))), dtype=object)) X = rs.rand(10) self.assertRaisesRegexp(ValueError, "Expected 2d array, got 1d array!", model.predict, X) X = rs.rand(10, 10, 10) self.assertRaisesRegexp(ValueError, "Expected 2d array, got 3d array!", model.predict, X) X = rs.rand(10, 5) self.assertRaisesRegexp(ValueError, "Rows in X should have 10 entries " "but have 5!", model.predict, X)
def test_predict_marginalized_over_instances_mocked(self, rf_mock): """Use mock to count the number of calls to predict()""" class SideEffect(object): def __call__(self, X): # Numpy array of number 0 to X.shape[0] rval = np.array(list(range(X.shape[0]))).reshape((-1, 1)) # Return mean and variance return rval, rval rf_mock.side_effect = SideEffect() rs = np.random.RandomState(1) F = rs.rand(10, 5) model = RandomForestWithInstances(np.zeros((15,), dtype=np.uint), instance_features=F, bounds=np.array(list(map(lambda x: (0, 10), range(10))), dtype=object)) means, vars = model.predict_marginalized_over_instances(rs.rand(11, 10)) self.assertEqual(rf_mock.call_count, 11) self.assertEqual(means.shape, (11, 1)) self.assertEqual(vars.shape, (11, 1)) for i in range(11): self.assertEqual(means[i], 4.5) self.assertEqual(vars[i], 4.5)
def test_train_and_predict_with_rf(self): rs = np.random.RandomState(1) X = rs.rand(20, 10) Y = rs.rand(10, 2) model = UncorrelatedMultiObjectiveRandomForestWithInstances( ['cost', 'ln(runtime)'], types=np.zeros((10, ), dtype=np.uint), bounds=np.array([ (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan), (0, np.nan) ], dtype=object), rf_kwargs={'seed': 1}, pca_components=5 ) self.assertEqual(model.estimators[0].seed, 1) self.assertEqual(model.estimators[1].seed, 1) self.assertEqual(model.pca_components, 5) model.train(X[:10], Y) m, v = model.predict(X[10:]) self.assertEqual(m.shape, (10, 2)) self.assertEqual(v.shape, (10, 2))
def _L(x): # initialize with zeros batch_size = x.shape[0] a = T.zeros((batch_size, num_actuators, num_actuators)) # set diagonal elements batch_idx = T.extra_ops.repeat(T.arange(batch_size), num_actuators) diag_idx = T.tile(T.arange(num_actuators), batch_size) b = T.set_subtensor(a[batch_idx, diag_idx, diag_idx], T.flatten(T.exp(x[:, :num_actuators]))) # set lower triangle cols = np.concatenate([np.array(range(i), dtype=np.uint) for i in xrange(num_actuators)]) rows = np.concatenate([np.array([i]*i, dtype=np.uint) for i in xrange(num_actuators)]) cols_idx = T.tile(T.as_tensor_variable(cols), batch_size) rows_idx = T.tile(T.as_tensor_variable(rows), batch_size) batch_idx = T.extra_ops.repeat(T.arange(batch_size), len(cols)) c = T.set_subtensor(b[batch_idx, rows_idx, cols_idx], T.flatten(x[:, num_actuators:])) return c
def __init__(self, max_timesteps, max_episodes, observation_shape, action_shape): self.max_timesteps = max_timesteps self.max_episodes = max_episodes self.observation_shape = observation_shape self.action_shape = action_shape self.preobs = np.empty((self.max_timesteps, self.max_episodes) + observation_shape) self.actions = np.empty((self.max_timesteps, self.max_episodes) + action_shape) self.rewards = np.empty((self.max_timesteps, self.max_episodes)) self.postobs = np.empty((self.max_timesteps, self.max_episodes) + observation_shape) self.terminals = np.empty((self.max_timesteps, self.max_episodes), dtype = np.bool) self.lengths = np.zeros(self.max_episodes, np.uint) self.num_episodes = 0 self.episode = 0 self.timestep = 0
def test_make_vector(self): mv = opt.make_vector(1, 2, 3) self.assertRaises( tensor.NotScalarConstantError, get_scalar_constant_value, mv) assert get_scalar_constant_value(mv[0]) == 1 assert get_scalar_constant_value(mv[1]) == 2 assert get_scalar_constant_value(mv[2]) == 3 assert get_scalar_constant_value(mv[numpy.int32(0)]) == 1 assert get_scalar_constant_value(mv[numpy.int64(1)]) == 2 assert get_scalar_constant_value(mv[numpy.uint(2)]) == 3 t = theano.scalar.Scalar('int64') self.assertRaises( tensor.NotScalarConstantError, get_scalar_constant_value, mv[t()])
def data_style_func(df): ''' Default value that can be used as callback for data_style_func Args: df: the dataframe that will be used to build the presentation model Returns: a function table takes idx, col as arguments and returns a dictionary of html style attributes ''' def _style_func(r, c): if isinstance(df.at[r,c], (np.int_, np.float, np.uint)): return td_style_to_str(default_numeric_td_style) return td_style_to_str(default_td_style) return _style_func
def matrix_size(udat, vdat, **kwargs): maxuv_factor = kwargs.get('maxuv_factor', 4.8) minuv_factor = kwargs.get('minuv_factor', 4.) uvdist = np.sqrt(udat**2 + vdat**2) maxuv = max(uvdist)*maxuv_factor minuv = min(uvdist)/minuv_factor minpix = np.uint(maxuv/minuv) Nuv = kwargs.get('force_nx', int(2**np.ceil(np.log2(minpix)))) return Nuv, minuv, maxuv
def _computeUnindexedVertexes(self): ## Given (Nv, 3, 3) array of vertexes-indexed-by-face, convert backward to unindexed vertexes ## This is done by collapsing into a list of 'unique' vertexes (difference < 1e-14) ## I think generally this should be discouraged.. faces = self._vertexesIndexedByFaces verts = {} ## used to remember the index of each vertex position self._faces = np.empty(faces.shape[:2], dtype=np.uint) self._vertexes = [] self._vertexFaces = [] self._faceNormals = None self._vertexNormals = None for i in xrange(faces.shape[0]): face = faces[i] inds = [] for j in range(face.shape[0]): pt = face[j] pt2 = tuple([round(x*1e14) for x in pt]) ## quantize to be sure that nearly-identical points will be merged index = verts.get(pt2, None) if index is None: #self._vertexes.append(QtGui.QVector3D(*pt)) self._vertexes.append(pt) self._vertexFaces.append([]) index = len(self._vertexes)-1 verts[pt2] = index self._vertexFaces[index].append(i) # keep track of which vertexes belong to which faces self._faces[i,j] = index self._vertexes = np.array(self._vertexes, dtype=float) #def _setUnindexedFaces(self, faces, vertexes, vertexColors=None, faceColors=None): #self._vertexes = vertexes #[QtGui.QVector3D(*v) for v in vertexes] #self._faces = faces.astype(np.uint) #self._edges = None #self._vertexFaces = None #self._faceNormals = None #self._vertexNormals = None #self._vertexColors = vertexColors #self._faceColors = faceColors
def _computeEdges(self): if not self.hasFaceIndexedData: ## generate self._edges from self._faces nf = len(self._faces) edges = np.empty(nf*3, dtype=[('i', np.uint, 2)]) edges['i'][0:nf] = self._faces[:,:2] edges['i'][nf:2*nf] = self._faces[:,1:3] edges['i'][-nf:,0] = self._faces[:,2] edges['i'][-nf:,1] = self._faces[:,0] # sort per-edge mask = edges['i'][:,0] > edges['i'][:,1] edges['i'][mask] = edges['i'][mask][:,::-1] # remove duplicate entries self._edges = np.unique(edges)['i'] #print self._edges elif self._vertexesIndexedByFaces is not None: verts = self._vertexesIndexedByFaces edges = np.empty((verts.shape[0], 3, 2), dtype=np.uint) nf = verts.shape[0] edges[:,0,0] = np.arange(nf) * 3 edges[:,0,1] = edges[:,0,0] + 1 edges[:,1,0] = edges[:,0,1] edges[:,1,1] = edges[:,1,0] + 1 edges[:,2,0] = edges[:,1,1] edges[:,2,1] = edges[:,0,0] self._edges = edges else: raise Exception("MeshData cannot generate edges--no faces in this data.")
def sphere(rows, cols, radius=1.0, offset=True): """ Return a MeshData instance with vertexes and faces computed for a spherical surface. """ verts = np.empty((rows+1, cols, 3), dtype=float) ## compute vertexes phi = (np.arange(rows+1) * np.pi / rows).reshape(rows+1, 1) s = radius * np.sin(phi) verts[...,2] = radius * np.cos(phi) th = ((np.arange(cols) * 2 * np.pi / cols).reshape(1, cols)) if offset: th = th + ((np.pi / cols) * np.arange(rows+1).reshape(rows+1,1)) ## rotate each row by 1/2 column verts[...,0] = s * np.cos(th) verts[...,1] = s * np.sin(th) verts = verts.reshape((rows+1)*cols, 3)[cols-1:-(cols-1)] ## remove redundant vertexes from top and bottom ## compute faces faces = np.empty((rows*cols*2, 3), dtype=np.uint) rowtemplate1 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 0]])) % cols) + np.array([[0, 0, cols]]) rowtemplate2 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 1]])) % cols) + np.array([[cols, 0, cols]]) for row in range(rows): start = row * cols * 2 faces[start:start+cols] = rowtemplate1 + row * cols faces[start+cols:start+(cols*2)] = rowtemplate2 + row * cols faces = faces[cols:-cols] ## cut off zero-area triangles at top and bottom ## adjust for redundant vertexes that were removed from top and bottom vmin = cols-1 faces[faces<vmin] = vmin faces -= vmin vmax = verts.shape[0]-1 faces[faces>vmax] = vmax return MeshData(vertexes=verts, faces=faces)
def cylinder(rows, cols, radius=[1.0, 1.0], length=1.0, offset=False): """ Return a MeshData instance with vertexes and faces computed for a cylindrical surface. The cylinder may be tapered with different radii at each end (truncated cone) """ verts = np.empty((rows+1, cols, 3), dtype=float) if isinstance(radius, int): radius = [radius, radius] # convert to list ## compute vertexes th = np.linspace(2 * np.pi, 0, cols).reshape(1, cols) r = np.linspace(radius[0],radius[1],num=rows+1, endpoint=True).reshape(rows+1, 1) # radius as a function of z verts[...,2] = np.linspace(0, length, num=rows+1, endpoint=True).reshape(rows+1, 1) # z if offset: th = th + ((np.pi / cols) * np.arange(rows+1).reshape(rows+1,1)) ## rotate each row by 1/2 column verts[...,0] = r * np.cos(th) # x = r cos(th) verts[...,1] = r * np.sin(th) # y = r sin(th) verts = verts.reshape((rows+1)*cols, 3) # just reshape: no redundant vertices... ## compute faces faces = np.empty((rows*cols*2, 3), dtype=np.uint) rowtemplate1 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 0]])) % cols) + np.array([[0, 0, cols]]) rowtemplate2 = ((np.arange(cols).reshape(cols, 1) + np.array([[0, 1, 1]])) % cols) + np.array([[cols, 0, cols]]) for row in range(rows): start = row * cols * 2 faces[start:start+cols] = rowtemplate1 + row * cols faces[start+cols:start+(cols*2)] = rowtemplate2 + row * cols return MeshData(vertexes=verts, faces=faces)
def generateFaces(self): cols = self._z.shape[1]-1 rows = self._z.shape[0]-1 faces = np.empty((cols*rows*2, 3), dtype=np.uint) rowtemplate1 = np.arange(cols).reshape(cols, 1) + np.array([[0, 1, cols+1]]) rowtemplate2 = np.arange(cols).reshape(cols, 1) + np.array([[cols+1, 1, cols+2]]) for row in range(rows): start = row * cols * 2 faces[start:start+cols] = rowtemplate1 + row * (cols+1) faces[start+cols:start+(cols*2)] = rowtemplate2 + row * (cols+1) self._faces = faces
def test_dtype_keyerrors_(self): # Ticket #1106. dt = np.dtype([('f1', np.uint)]) assert_raises(KeyError, dt.__getitem__, "f2") assert_raises(IndexError, dt.__getitem__, 1) assert_raises(ValueError, dt.__getitem__, 0.0)
def get_val_indices_uniform(m_total, m_val): all_idxs = np.arange(m_total) samps_per_class = m_val / NUM_CLASSES val_idxs = np.array([]) for i in range(NUM_CLASSES): all_class_idxs = all_idxs[( all_idxs % NUM_CLASSES == i)] sel_class_idxs = np.random.choice(all_class_idxs, samps_per_class, replace=False) val_idxs = np.concatenate((val_idxs,sel_class_idxs)) np.random.shuffle(val_idxs) return val_idxs.astype(np.uint)
def get_val_indices(m_total, m_val, info_mat): all_idxs = np.arange(m_total) val_idxs = np.array([]) for i in range(NUM_CLASSES): cat_for_val = np.random.choice(TR_CATS,1)[0] all_class_idxs = all_idxs[( all_idxs % NUM_CLASSES == i)] class_info = info_mat[all_class_idxs] sel_class_idxs = np.where(class_info[:,0] == cat_for_val)[0] val_idxs = np.concatenate((val_idxs,all_class_idxs[sel_class_idxs])) np.random.shuffle(val_idxs) return val_idxs.astype(np.uint)
def __init__(self, img): self.img = np.asarray(img, np.float32) # The image to be handled; self.img2 = img # The real image; self.rows, self.cols = get_size(img) self.mask = np.zeros((self.rows, self.cols), dtype = np.uint) # In this class, we use just one mask to contain the Ms and Ml in the paper; In the mask, the places where the value = self._SHADOW belongs to Ms, and other pixels belongs to Ml; self.trimap = np.zeros((self.rows, self.cols), dtype = np.uint) # The trimap containing info that whether a pixel is inside the shadow, outside the shadow, or unknown; self.mask_shadow = np.zeros((self.rows, self.cols), dtype = np.uint) # The area where shadow removal is required; self._SHADOW = 1 # The flag of shadow; self._LIT = 0 # The flag of lit; self._UNKNOWN = -1 # The flag of unknown; self._threshold = 0.1; self._drawing = True # The flag of drawing; self._drawn = False # The status of whether seed initialise is finished;
def saveTxt(filename, ndarray): with open(filename, 'w') as f: labels = list(map(' '.join, np.eye(10, dtype=np.uint).astype(str))) for row in ndarray: row_str = row.astype(str) label_str = labels[row[-1]] feature_str = ' '.join(row_str[:-1]) f.write('|labels {} |features {}\n'.format(label_str, feature_str))
def make_stack(series): stack_size = compute_stack_size(series) new = np.empty(stack_size, dtype=[('doc_index', np.uint), ('word', "S30"), ('value', np.float)]) counter = 0 for row in series.iteritems(): for word in row[1]: new[counter] = (row[0], word, row[1][word]) counter +=1 return new
def get_articles_by_distance(article, corpus): #article is the row from the articles df article = corpus[article['index'],:] iterable = ((x, cosine_distance(article, corpus[x,:])) for x in range(corpus.shape[0])) articles_by_distance = np.fromiter(iterable, dtype='uint,float', count=corpus.shape[0]) articles_by_distance = pd.DataFrame(articles_by_distance).rename(columns={'f1':'cosine_distance', 'f0':'index'}).sort_values(by='cosine_distance') return articles_by_distance[0:25]
def backproject_depth(self, depth): constant_x = 1.0 / self.focal_x constant_y = 1.0 / self.focal_y row, col = depth.shape coords = np.zeros((row, col, 2), dtype=np.uint) coords[..., 0] = np.arange(row)[:, None] coords[..., 1] = np.arange(col) coords = coords.reshape((-1, 2)) output = np.zeros((len(coords), 3)) values = depth[coords[:, 0], coords[:, 1]] output[:, 0] = (coords[:, 1] - self.center_x) * values * constant_x output[:, 1] = (coords[:, 0] - self.center_y) * values * constant_y output[:, 2] = values return output
def testIntArray(self): arr = np.arange(100, dtype=np.int) dtypes = (np.int, np.int8, np.int16, np.int32, np.int64, np.uint, np.uint8, np.uint16, np.uint32, np.uint64) for dtype in dtypes: inpt = arr.astype(dtype) outp = np.array(ujson.decode(ujson.encode(inpt)), dtype=dtype) tm.assert_numpy_array_equal(inpt, outp)
def transNK(self, d, N, problem_arg=0): # return np.arange(0, N), np.arange(0, N) # Each ind has 2*|ind|_0 samples indSet = setutil.GenTDSet(d, N, base=0) N_per_ind = 2**np.sum(indSet!=0, axis=1) if problem_arg == 1: N_per_ind[1:] /= 2 _, k_ind = np.unique(np.sum(indSet, axis=1), return_inverse=True) k_of_N = np.repeat(k_ind, N_per_ind.astype(np.int))[:N] # N_of_k = [j+np.arange(0, i, dtype=np.uint) for i, j in # zip(N_per_ind, np.hstack((np.array([0], # dtype=np.uint), # np.cumsum(N_per_ind)[:np.max(k_of_N)])))] return k_of_N
def test_json_numpy_encoder_int(self): assert (json.dumps(np.uint(10), cls=utils.JSONNumpyEncoder) == json.dumps(10))
def test_json_numpy_encoder_int_array(self): array = np.arange(10, dtype=np.uint).reshape(2, 5) assert (json.dumps(array, cls=utils.JSONNumpyEncoder) == json.dumps(array.tolist()))
def test_serialize_json(self): array = np.arange(10, dtype=np.uint).reshape(2, 5) assert (utils.serialize_json(array) == json.dumps(array.tolist()))
def is_integer(test_value): """ Check all available integer representations. @return: bool, True if the passed value is a integer, otherwise false. """ return type(test_value) in [np.int, np.int8, np.int16, np.int32, np.int64, np.uint, np.uint8, np.uint16, np.uint32, np.uint64]
def mask_od_vessels(skel, od_center): # Create optic disk mask od_mask = np.zeros_like(skel, dtype=np.uint8) cv2.circle(od_mask, od_center, 30, (1, 1, 1), -1) od_mask_inv = np.invert(od_mask) / 255. skel = skel.astype(np.float) masked_skel = skel * od_mask_inv return masked_skel.astype(np.uint8) # def line_diameters(edt, lines): # # diameters = [] # # for line in lines: # # p0, p1 = [np.asarray(pt) for pt in line] # vec = p1 - p0 # vector between segment end points # vec_len = np.linalg.norm(vec) # # pts_along_line = np.uint(np.asarray([p0 + (i * vec) for i in np.arange(0., 1., 1. / vec_len)])) # # for pt in pts_along_line: # # try: # diameters.append(edt[pt[0], pt[1]]) # except IndexError: # pass # # return diameters
def train(self, X: np.ndarray, Y: np.ndarray, **kwargs): """Trains the EPM on X and Y. Parameters ---------- X : np.ndarray [n_samples, n_features (config + instance features)] Input data points. Y : np.ndarray [n_samples, n_objectives] The corresponding target values. n_objectives must match the number of target names specified in the constructor. Returns ------- self : AbstractEPM """ self.n_params = X.shape[1] - self.n_feats # reduce dimensionality of features of larger than PCA_DIM if self.pca and X.shape[0] > 1: X_feats = X[:, -self.n_feats:] # scale features X_feats = self.scaler.fit_transform(X_feats) X_feats = np.nan_to_num(X_feats) # if features with max == min # PCA X_feats = self.pca.fit_transform(X_feats) X = np.hstack((X[:, :self.n_params], X_feats)) if hasattr(self, "types"): # for RF, adapt types list # if X_feats.shape[0] < self.pca, X_feats.shape[1] == # X_feats.shape[0] self.types = np.array(np.hstack((self.types[:self.n_params], np.zeros((X_feats.shape[1])))), dtype=np.uint) return self._train(X, Y)
def test_predict(self): rs = np.random.RandomState(1) X = rs.rand(20, 10) Y = rs.rand(10, 1) model = RandomForestWithInstances(np.zeros((10,), dtype=np.uint), bounds=np.array( list(map(lambda x: (0, 10), range(10))), dtype=object)) model.train(X[:10], Y[:10]) m_hat, v_hat = model.predict(X[10:]) self.assertEqual(m_hat.shape, (10, 1)) self.assertEqual(v_hat.shape, (10, 1))
def test_train_with_pca(self): rs = np.random.RandomState(1) X = rs.rand(20, 20) F = rs.rand(10, 10) Y = rs.rand(20, 1) model = RandomForestWithInstances(np.zeros((20,), dtype=np.uint), np.array(list(map(lambda x: (0, 10), range(10))), dtype=object), pca_components=2, instance_features=F) model.train(X, Y) self.assertEqual(model.n_params, 10) self.assertEqual(model.n_feats, 10) self.assertIsNotNone(model.pca) self.assertIsNotNone(model.scaler)
