def _graph_constant(g, value, dims, type, *args, **kwargs): assert isinstance(value, numbers.Number) assert type is not None isscalar = False if dims is None or dims == 0 or set(dims) == set([0]): dims = [1] isscalar = True type = type.lower() if type == "char": tensor = torch.CharTensor(*dims) elif type == "short": tensor = torch.ShortTensor(*dims) elif type == "int": tensor = torch.IntTensor(*dims) elif type == "long": tensor = torch.LongTensor(*dims) elif type == "half": tensor = torch.HalfTensor(*dims) elif type == "float": tensor = torch.FloatTensor(*dims) elif type == "double": tensor = torch.DoubleTensor(*dims) else: raise ValueError( "Unknown type, type should be one of the following strings: " "char, short, int, long, half, float, double") tensor.fill_(value) if isscalar: return g.op("Constant", *args, value_z=tensor, **kwargs) return g.op("Constant", *args, value_t=tensor, **kwargs)
def store(self, state, action, reward, next_state, done): state = from_numpy(state).byte().to("cpu") reward = torch.CharTensor([reward]) action = torch.ByteTensor([action]).to('cpu') next_state = from_numpy(next_state).byte().to('cpu') done = torch.BoolTensor([done]) self.memory.add(state, reward, done, action, next_state)
def convert_to_1hot(target, noutputs, make_11=True): if target.is_cuda: target_1hot = torch.cuda.CharTensor(target.size()[0], noutputs) else: target_1hot = torch.CharTensor(target.size()[0], noutputs) target_1hot.zero_() target_1hot.scatter_(1, target.unsqueeze(1), 1) target_1hot = target_1hot.type(target.type()) if make_11: target_1hot = target_1hot * 2 - 1 return target_1hot
def __init__(self, schema=None, mask_value=0): if schema is None: schema = uniread.schema.load_default_schema() self.schema = schema self.one_hot_converter = UnimorphTagBitVectorConverter(schema) self.mask_value = mask_value self.mask = torch.CharTensor(len(self.schema), len(self.one_hot_converter)).zero_() mask_offset = 0 for row_id, schema_group in enumerate(self.schema.values()): self.mask[row_id, mask_offset:mask_offset + len(schema_group)] = 1 mask_offset += len(schema_group)
def test_all_dtypes(): return ( torch.BoolTensor([2]), torch.LongTensor([3]), torch.ByteTensor([4]), torch.CharTensor([5]), torch.DoubleTensor([6]), torch.FloatTensor([7]), torch.IntTensor([8]), torch.ShortTensor([1]), torch.HalfTensor([1]), )
def test_cast_variable(self): inputs = [ torch.ByteTensor(1), torch.CharTensor(1), torch.DoubleTensor(1), torch.FloatTensor(1), torch.IntTensor(1), torch.LongTensor(1), torch.ShortTensor(1), ] for inp in inputs: assert type(inp) == type(torch.cast(Variable(inp), type(inp)).data)
def _graph_constant( g, value, dims, type_: str, *args, **kwargs, ): """This helper function can create either constant tensor or constant scalar. If dims is None or 0 or [0], generate a 0-d tensor (scalar). """ assert isinstance(value, numbers.Number) assert type_ is not None isscalar = False if dims is None or dims == 0 or set(dims) == {0}: dims = [1] isscalar = True type_ = type_.lower() tensor: Union[ torch.CharTensor, torch.ShortTensor, torch.IntTensor, torch.LongTensor, torch.HalfTensor, torch.FloatTensor, torch.DoubleTensor, ] if type_ == "char": tensor = torch.CharTensor(*dims) elif type_ == "short": tensor = torch.ShortTensor(*dims) elif type_ == "int": tensor = torch.IntTensor(*dims) elif type_ == "long": tensor = torch.LongTensor(*dims) elif type_ == "half": tensor = torch.HalfTensor(*dims) elif type_ == "float": tensor = torch.FloatTensor(*dims) elif type_ == "double": tensor = torch.DoubleTensor(*dims) else: raise ValueError( "Unknown type, type should be one of the following strings: " "char, short, int, long, half, float, double" ) tensor.fill_(value) # type: ignore[call-overload] if isscalar: return g.op("Constant", *args, value_z=tensor, **kwargs) return g.op("Constant", *args, value_t=tensor, **kwargs)
def changeIndexesExtr_test1(): cm = torch.CharTensor(25, 32).zero_() cm = torch.CharTensor(129, 254).zero_() ci_ref = [] def insertChange(y, x): cm[y][x] = 1 ci_ref.append(y * cm.size(-1) + x) insertChange(3, 3) insertChange(7, 5) insertChange(5, 7) insertChange(7, 1) insertChange(1, 5) insertChange(24, 31) ci_ref = torch.IntTensor(ci_ref) cm = cm.cuda() # ci_gpu, cnt_gpu = changeIndexesExtr(cm) ci = changeIndexesExtr_python(cm) passed = (ci_ref.sort()[0] == ci.cpu().sort()[0]).all() return passed
def occupy(self): if hasattr(self, 'memory'): print('Already busy') else: t = time() free = get_gpu_memory_map(False) used = get_gpu_memory_map(True) total = free[self.gpu] + used[self.gpu] print("Occupying memory: currently at {}/{}".format( used[self.gpu], total)) self.memory = torch.CharTensor(int(free[self.gpu] * 1e6 * .9)).cuda() used_after = get_gpu_memory_map(True) print("Done. Memory: {0:d}/{1:d} [{2:.1f} s.]".format( used_after[self.gpu], total, time() - t))
def test_abs(self): def _test_abs(tensors_dict): for _category, tensors in tensors_dict.items(): for data in tensors: _test_abs_single(data) def _test_abs_single(data): switch = torch.rand( data.size(), device=device).mul(2).floor().mul(2).add(-1).type(data.dtype) res = torch.mul(data, switch) self.assertTensorsSlowEqual(res.abs(), data, 1e-16) shapes = [(3, 4), (3, 5, 7), (2, 2, 5, 8, 2, 3), (1000, ), (10, 10, 10)] for shape in shapes: # Test all except char/byte _test_abs(self._make_tensors(shape, val_range=(0, 1000))) # Test char _test_abs_single(torch.CharTensor(*shape).random_(0, 100)) # Test byte byte_tensor = torch.ByteTensor(*shape).random_(0, 100) self.assertTensorsSlowEqual(byte_tensor, byte_tensor.abs(), 1e-16) # Checking that the right abs function is called for LongTensor bignumber = 2**31 + 1 res = torch.LongTensor((-bignumber, )) self.assertGreater(res.abs()[0], 0) # One of rec = torch.randn(2, 2, 3, 7, 6, 2).type(torch.float64).clamp(0, 1) val1 = rec.select(-1, -1).data[0][0][0].sum() val2 = rec.select(-1, -1).data.abs()[0][0][0].sum() self.assertEqual(val1, val2, 1e-8, 'absolute value') # Both abs(0.0) and abs(-0.0) should result in 0.0 for dtype in (torch.float, torch.double): for abs_zeros in ( torch.tensor([0.0, -0.0], dtype=dtype).abs().tolist(), # test a large tensor so that the vectorized version is tested torch.abs(-torch.zeros(10000, dtype=dtype)).tolist()): for num in abs_zeros: self.assertGreater(math.copysign(1.0, num), 0.0)
def onehot_to_chars(embedded_text: Tensor, idx_to_char: dict) -> str: """ Reverses the embedding of a text sequence, producing back the original sequence as a string. :param embedded_text: Text sequence represented as a tensor of shape (N, D) where each row is the one-hot encoding of a character. :param idx_to_char: Mapping from indices to characters. :return: A string containing the text sequence represented by the embedding. """ # TODO: Implement the reverse-embedding. # ====== YOUR CODE: ====== index = range(len(idx_to_char)) index_vec = torch.CharTensor(index) result = "" string_indices = embedded_text @ index_vec for index in string_indices: result += idx_to_char[int(index)] # ======================== return result
import torch from torch.autograd import Variable # 3行2列的tensor矩阵 a = torch.Tensor(3, 2) print(a) print(a.size()) b = torch.Tensor(3, 2, 2) print(b) c = torch.IntTensor(2, 2) print(c) print(torch.ByteTensor(3, 2)) print(torch.CharTensor(3, 2)) print(torch.DoubleTensor(3, 2)) a = torch.arange(6).view(3, 2) print(a) b = torch.arange(6).view(2, 3) print(b) print(a @ b) # print(torch.dot(a,b))# dot只能用于一维向量 print(torch.matmul(a, b)) print(torch.mm(a, b)) # 数学中的矩阵乘法 print(a.t()) print(a.numel()) # 求a中的元素个数 a = torch.arange(1, 4) b = torch.arange(1, 4)
import torch lt = torch.LongTensor([1,2,3,4]) print(lt) print(lt.float()) print() bt = torch.ByteTensor([True,False,False,True]) ct = torch.CharTensor([True,False,False,True]) print(bt) print(bt.long()) print(bt.float()) print() print(ct) print(ct.long()) print(ct.float()) print() ft = torch.FloatTensor([True,False,False,True]) print(ft) print(ft.long())
second_point[0] = 4 print("\nclone has changed the original tensor?", id(points[1]) == id(second_point)) print("transpose of points:\n", points.t()) #transpose print("stride of points:", points.stride()) print("stride of transposed points:", points.t().stride()) print("points is contiguous?", points.is_contiguous()) points_con = points.t().contiguous() print("transpose of points is contiguous?", points.t().is_contiguous(), " after contiguous method to points.t():", points_con.is_contiguous()) ##2.4 Numeric types double_points = torch.zeros(10, 2).double() #method short_points = torch.tensor([[1, 2], [3, 4]], dtype=torch.short) #argument char_points = torch.CharTensor([[1, 2]]) #default print("\ndtype of double float:", double_points.dtype) print("dtype of short int:", short_points.dtype) print("dtype of char:", char_points.dtype) rand_points = torch.randn(10, 2).type(torch.short) #method print( "\nyou can cast a tensor of one type as a tensor of another type by using 'type' method:\n#rand_points = torch.randn(10, 2).type(torch.short)\ndtype of rand_points:", rand_points.dtype) ##2.6 NumPy interoperability points = torch.tensor([[1, 1, 1], [2, 2, 2]]) points_np = points.numpy() print( "from NumPy out of tensor:\n", points_np) #the array shares an underlying buffer with the tensor storage
model = DanQ() elif args.model_type == 5: model = BassetNormCat() num_params = sum([p.numel() for p in model.parameters()]) model.cuda() print("Model successfully imported\nTotal number of parameters {}".format( num_params), file=Logger) start = time.time() print("Reading data from file {}".format(args.data), file=Logger) data = h5py.File(args.data) train = torch.utils.data.TensorDataset(torch.CharTensor(data['train_in']), torch.CharTensor(data['train_out'])) val = torch.utils.data.TensorDataset(torch.CharTensor(data['valid_in']), torch.CharTensor(data['valid_out'])) test = torch.utils.data.TensorDataset(torch.CharTensor(data['test_in']), torch.CharTensor(data['test_out'])) train_loader = torch.utils.data.DataLoader(train, batch_size=args.batch_size, shuffle=True) # train_loader = torch.utils.data.DataLoader(train, batch_size=args.batch_size, shuffle=True, num_workers=int(args.workers)) val_loader = torch.utils.data.DataLoader(val, batch_size=args.batch_size, shuffle=False) # val_loader = torch.utils.data.DataLoader(val, batch_size=args.batch_size, shuffle=False, num_workers=int(args.workers)) test_loader = torch.utils.data.DataLoader(test, batch_size=args.batch_size,
assert 0 == 1, "--cell_set flag must be 'train', 'valid', or 'test'" c_idx = [ i for i, x in enumerate(list(data['target_labels'][:])) if str(x, 'utf-8') in get_type ] if args.cell_set == 'all': v_idx = [ i for i, x in enumerate(list(data['target_labels'][:])) if str(x, 'utf-8') in valid_type ] else: v_idx = c_idx train = torch.utils.data.TensorDataset( torch.CharTensor(data['train_in'][:]), torch.CharTensor(data['train_out'][:, c_idx])) val = torch.utils.data.TensorDataset( torch.CharTensor(data['valid_in'][:]), torch.CharTensor(data['valid_out'][:, c_idx])) test = torch.utils.data.TensorDataset( torch.CharTensor(data['test_in'][:]), torch.CharTensor(data['test_out'][:, c_idx])) train_loader = torch.utils.data.DataLoader(train, batch_size=args.batch_size, shuffle=True) # train_loader = torch.utils.data.DataLoader(train, batch_size=args.batch_size, shuffle=True, num_workers=int(args.workers)) val_loader = torch.utils.data.DataLoader(val, batch_size=args.batch_size, shuffle=False) # val_loader = torch.utils.data.DataLoader(val, batch_size=args.batch_size, shuffle=False, num_workers=int(args.workers))