在 TF 中，一个张量如下表述：

my_tensor = tf.constant(0., shape=[6,3,7])
print(my_tensor) # -> Tensor("Const_1:0", shape=(6, 3, 7), dtype=float32)


  一个张量应该包含如下内容：

一个名字，它用于键值对的存储，用于后续的检索： Const: 0
一个形状描述， 描述数据的每一维度的元素个数：（6，3，7）
数据类型，比如 float32
  从向量空间到实数域的多重线性映射(multilinear maps)。

  在 TensorFlow 中用 tensor 数据结构来代表所有的数据, 计算图中, 操作间传递的数据都是 tensor。

  张量是一个拥有 n 维度的数组，并且其中的值都拥有相同的类型，比如整型，浮点型，布尔型等等。

  张量可以用我们所说的形状来描述：我们用列表（或元祖）来描述我们的张量的每个维度的大小

不同维度的Tensor
  
俗称
  
表示方法
n 维度的张量
  
多维数组
  
（D_0, D_1, D_2, …, D_n-1）
W x H 大小的张量
  
矩阵
  
（W, H）
尺度是 W 的张量
  
向量
  
（W, ）
０维度的张量
  
标量
  
（）或（1, ）
  注意： D_*，W，H 都是整型。

Tensor 种类
  
Annotation
常值张量(constant)
  
是不需要初始化的。
变量(Variable)
  
是维护图执行过程中的状态信息的. 需要它来保持和更新参数值，是需要动态调整的。必须先通过 tf.global_variables_initializer() 初始化，然后才有值。

tensor2tensor to train all the need is attention model

参数定义:

通过 create_experiment调用train_utils.create_hparams,调用函数problem_hparams.problem_hparams,之后调用transormer,transformer调用common_hparams得到基本的模型参数,并在transformer中补充参数.

模型调用:

trainer_utils._cond_on_index调用fn(cur_idx),fn为trainer_utils.model_fn.nth_model,调用

t2t_model._with_timing.fn_with_timing调用fn,fn调用transformer.model_fn_body得到loss,logits.

训练数据生成:

函数为tensor2tensor/bin/t2t-datagen.py

对于每个任务和数据集,都分别定义了其数据生成函数,所有任务数据处理函数定义在词典_SUPPORTED_PROBLEM_GENERATORS中

例如要训练en-fr的attention is  all you need模型,其数据处理函数定义为:

“wmt_enfr_tokens_32k”: (    lambda: wmt.enfr_wordpiece_token_generator(FLAGS.tmp_dir, True, 2**15),    lambda: wmt.enfr_wordpiece_token_generator(FLAGS.tmp_dir, False, 2**15))

enfr_wordpiece_token_generator定义在wmt中,代码如下:



def enfr_wordpiece_token_generator(tmp_dir, train, vocab_size):
  """Instance of token generator for the WMT en->fr task."""
  symbolizer_vocab = generator_utils.get_or_generate_vocab(
      tmp_dir, "tokens.vocab.%d" % vocab_size, vocab_size)
  datasets = _ENFR_TRAIN_DATASETS if train else _ENFR_TEST_DATASETS
  tag = "train" if train else "dev"
  data_path = _compile_data(tmp_dir, datasets, "wmt_enfr_tok_%s" % tag)
  return token_generator(data_path + ".lang1", data_path + ".lang2",
                         symbolizer_vocab, 1)

首先generator_utils.get_or_generate_vocab函数生成词典,_ENFR_TRAIN_DATASETS 为包含输入数据的词典,token_generator函数读取训练数据,并将其转换为数字:



def token_generator(source_path, target_path, token_vocab, eos=None):
  eos=token_vocab['</S>']
  eos_list = [] if eos is None else [eos]
  with tf.gfile.GFile(source_path, mode="r") as source_file:
    with tf.gfile.GFile(target_path, mode="r") as target_file:
      source, target = source_file.readline(), target_file.readline()
      while source and target:
        source_ints = word_num(source.strip('\n'),token_vocab) + eos_list#change text to number and end with eos1
        target_ints = word_num(target.strip('\n'),token_vocab) + eos_list
        slen=max(len(source_ints),len(target_ints))
        if slen>=5 and slen<=20:#control the training sentence to be [5,20]
            yield {"inputs": source_ints, "targets": target_ints}
        source, target = source_file.readline(), target_file.readline()

在Pytorch中，Tensor和tensor都用于生成新的张量。
>>>  a = torch.Tensor([1, 2])
>>>  a
tensor([1., 2.])
>>> a=torch.tensor([1,2])
>>> a
tensor([1, 2])

首先我们从根源上来看看torch.Tensor()和torch.tensor()区别。
torch.Tensor
torch.Tensor()是Python类，更明确的说，是默认张量类型torch.FloatTensor()的别名，torch.Tensor([1,2]) 会调用Tensor类的构造函数__init__，生成单精度浮点类型的张量。
>>> a=torch.Tensor([1,2])
>>> a.type()
'torch.FloatTensor'

torch.tensor()
torch.tensor()仅仅是Python的函数，函数原型是：
torch.tensor(data, dtype=None, device=None, requires_grad=False)

其中data可以是：list, tuple, array, scalar等类型。

torch.tensor()可以从data中的数据部分做拷贝（而不是直接引用），根据原始数据类型生成相应的torch.LongTensor，torch.FloatTensor，torch.DoubleTensor。
>>> a = torch.tensor([1, 2])
>>> a.type()
'torch.LongTensor'

>>> a = torch.tensor([1., 2.])
>>> a.type()
'torch.FloatTensor'

>>> a = np.zeros(2, dtype=np.float64)
>>> a = torch.tensor(a)
>>> a.type()
torch.DoubleTensor

Reference:

https://blog.csdn.net/tfcy694/article/details/85338745

Tensor
torch.Tensor() 是类，不同的数据类型对应不同的类，一共有九种（图片来自于官方文档截图）：

torch.Tensor 是 torch.FloatTensor 的一个别名。不同类之间的转换可以用 type() 函数，如：
import torch

a = torch.Tensor([1, 2, 3])
b = a.type(torch.LongTensor)

tensor
torch.tensor() 是一个函数，它返回值是上面的某个类：
torch.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False) → Tensor

它通过dtype来确定是哪种数据类型。