• 感觉seq3代码是我看到的写得前2好的代码，另外的代码是transformer-xl
• 所有的超参数都是从yaml文件中读取的，训练的时候只用指定配置文件即可，感觉和把超参放入sh文件中的方法差不多好。train_options函数返回return args, config，其中config是将yaml文件里面的东西变成了逐层的字典。

python models/sent_lm.py --config model_configs/camera/lm_prior.yaml 

sent_lm

• 先是使用train_options读取参数，读取出来的config是一个字典。
  
• 可以看到arg里面主要是对这次训练的描述，比如是否进行可视化,本次训练的名字是什么，描述是什么，resume是重新训练的ckpt的地址，使用gpu还是cpu等等，而config里面就是本次训练的超参数。
  

• 几种加载词典的方式。

• 加载数据。

dataset 数据加载

• 首先所有的dataset都继承自torch.utils.data中的Dataset，有两种构建单词表的方法，一种是subword的一种是普通的
  
• 一个写的比较好的地方就是和fairseq他们一样，首先对原始的文本进行处理，然后存放一个处理后的二进制文本，然后以后每次训练的时候只是使用这个二进制文件，这里是用pickle实现的，注意这个直接是吧一个函数的返回值完全打包了，而且是根据输入的文件名通过

        args_str = ''.join(args_to_str(args))
        key = hashlib.md5(args_str.encode()).hexdigest()
        cache_file = os.path.join(cache_dir, key)

• 创建了一个独特的读取码，然后判断文件存不存在，如果存在的话那么就使用pickle读取文件，如果是第一次调用不存在的话那么就先读取data，然后创建。

def disk_memoize(func):
    cache_dir = os.path.join(BASE_DIR, "_cache")
    if not os.path.exists(cache_dir):
        os.makedirs(cache_dir)

    @functools.wraps(func)
    def wrapper_decorator(*args, **kwargs):
        # check fn arguments
        args_str = ''.join(args_to_str(args))
        key = hashlib.md5(args_str.encode()).hexdigest()
        cache_file = os.path.join(cache_dir, key)

        if os.path.exists(cache_file):
            print(f"Loading {cache_file} from cache!")
            with open(cache_file, 'rb') as f:
                return pickle.load(f)
        else:
            print(f"No cache file for {cache_file}...")
            data = func(*args, **kwargs)

            with open(cache_file, 'wb') as pickle_file:
                pickle.dump(data, pickle_file)

            return data

    return wrapper_decorator

# @disk_memoize
def read_corpus(file, tokenize):
    _vocab = Vocab()

    _data = []
    for line in iterate_data(file):
        tokens = tokenize(line)
        _vocab.read_sequence(tokens)
        _data.append(tokens)

    return _vocab, _data

• iterate_data也写的很好，使用isinstance来判断，如果传入的是字符串，那么就open，如果传入的是一个可迭代的collections.Iterable那么就直接yield，而且这里的tqdm写的也很好的，total指定全部的数据，wc是使用linux里面的wc命令，通过suprocess的check_output调用。

from subprocess import check_output
def wc(filename):
    return int(check_output(["wc", "-l", filename]).split()[0])

def iterate_data(data):
    if isinstance(data, str):
        assert os.path.exists(data), f"path `{data}` does not exist!"
        with open(data, "r") as f:
            for line in tqdm(f, total=wc(data), desc=f"Reading {data}..."):
                if len(line.strip()) > 0:
                    yield line

    elif isinstance(data, collections.Iterable):
        for x in data:
            yield x

• 如果是使用subword，那么就要import sentencepiece as spm，然后使用subword的model进行切词。
  
• 回到BaseLMDataset上，可以看到里面有一个__str__方法目的是为了将这个类变成一个字符串，这样直接print这个类的实例的话，就会将__str__中的东西打印出来。我们还可以看到作者这里使用了一个，这样就可以将一个列表按照表格的形式显示。

from tabulate import tabulate
return tabulate([[x[1] for x in props]], headers=[x[0] for x in props])

from tabulate import tabulate

props = [('ni','7889'),('taa','890988'),('you','safdkk')]
print(tabulate([[x[1] for x in props]], headers=[x[0] for x in props])) 
---------------------------------------输入----------------------------------
  ni     taa  you
----  ------  ------
7889  890988  safdkk

• BaseLMDataset介绍完了接下来是class SentenceLMDataset(BaseLMDataset):这个很简单只用实例化__len__和__getitem__，因为self.data是一个列表，因此对于LM来说input和target构造好，以及句子的长度
  
• 接下来是sampler和loader，
  
• BucketBatchSampler就是根据句子的长度进行排序（这样做的目的是让一个batch内部的数据尽可能长度是一致的），然后返回。
  
• 有一个很有意思的是是虽然设置的是，前面的一个是将数据分成预设的batch size，也就是平均会有1/2个batch size的数据被丢弃掉，而用了第二种的话会让batch size接近预设的batch size但是丢弃的数据是最少的。
  
• from torch.nn.utils.rnn import pad_sequence，在新的位置按照0来填充，填充到最大长度。
  
• collate_fn是将batch_sampler中，我们可以看到_collate函数的传入参数是和train_set中的__getitem__的返回值是一样的。
• 也就是说顺序是train_set提供__len__和__getitem__，train_sampler打包成batch，然后collate_fn做后处理，就是进行Padding和转换成LongTensor。
  

model 构建模型

• 模型的总体，loss_function = nn.CrossEntropyLoss(ignore_index=0)直接就可以不对mask的做crossEntropyLoss，optimizer = optim.Adam(parameters, lr=config["lr"], weight_decay=config["weight_decay"])，l2正则化等价于weight_decay,得到模型后model.to(device)
  
• tensor.numel()返回的是这个tensor中总共有多少个tensor

>>> a = torch.randn(1, 2, 3, 4, 5)
>>> torch.numel(a)

• 统计有多少参数，以一个易懂的方式展现出来。

model中的RNNModule

• 众所周知，lstm中的rnn需要进去的时候降序，然后出来的时候再恢复原始的顺序，可以看到作者的方法还是比较巧妙的,先对tensor进行降序得到降序的下标，然后对下标再升序排序之后得到的就是能恢复的顺序，x = x[sorted_i]，outputs = out_unpacked[reverse_i]

class RNNModule(nn.Module, RecurrentHelper):
    def __init__(self, input_size,
                 rnn_size,
                 num_layers=1,
                 bidirectional=False,
                 dropout=0.,
                 pack=True, last=False, countdown=False):
        """
        A simple RNN Encoder, which produces a fixed vector representation
        for a variable length sequence of feature vectors, using the output
        at the last timestep of the RNN.
        Args:
            input_size (int): the size of the input features
            rnn_size (int):
            num_layers (int):
            bidirectional (bool):
            dropout (float):
        """
        super(RNNModule, self).__init__()

        self.pack = pack
        self.last = last
        self.countdown = countdown

        if self.countdown:
            self.Wt = nn.Parameter(torch.rand(1))
            input_size += 1

        self.rnn = nn.LSTM(input_size=input_size,
                           hidden_size=rnn_size,
                           num_layers=num_layers,
                           bidirectional=bidirectional,
                           batch_first=True)

        # the dropout "layer" for the output of the RNN
        self.dropout = nn.Dropout(dropout)

        # define output feature size
        self.feature_size = rnn_size

        # double if bidirectional
        if bidirectional:
            self.feature_size *= 2

    @staticmethod
    def reorder_hidden(hidden, order):
        if isinstance(hidden, tuple):
            hidden = hidden[0][:, order, :], hidden[1][:, order, :]
        else:
            hidden = hidden[:, order, :]

        return hidden

    def forward(self, x, hidden=None, lengths=None):

        batch, max_length, feat_size = x.size()

        if lengths is not None and self.pack:

            ###############################################
            # sorting
            ###############################################
            lenghts_sorted, sorted_i = lengths.sort(descending=True)
            _, reverse_i = sorted_i.sort()

            x = x[sorted_i]

            if hidden is not None:
                hidden = self.reorder_hidden(hidden, sorted_i)

            ###############################################
            # forward
            ###############################################

            if self.countdown:
                ticks = length_countdown(lenghts_sorted).float() * self.Wt
                x = torch.cat([x, ticks.unsqueeze(-1)], -1)

            packed = pack_padded_sequence(x, lenghts_sorted, batch_first=True)

            self.rnn.flatten_parameters()
            out_packed, hidden = self.rnn(packed, hidden)

            out_unpacked, _lengths = pad_packed_sequence(out_packed,
                                                         batch_first=True,
                                                         total_length=max_length)

            out_unpacked = self.dropout(out_unpacked)

            ###############################################
            # un-sorting
            ###############################################
            outputs = out_unpacked[reverse_i]
            hidden = self.reorder_hidden(hidden, reverse_i)

        else:
            # todo: make hidden return the true last states
            self.rnn.flatten_parameters()
            outputs, hidden = self.rnn(x, hidden)
            outputs = self.dropout(outputs)

        if self.last:
            return outputs, hidden, self.last_timestep(outputs, lengths,
                                                       self.rnn.bidirectional)

        return outputs, hidden

• 设置batch_first=True，然后复原原来的顺序，所以说迭几层的LSTM实现起来真的很简单。
  
• hidden_reorder的实现很简单，hidden的顺序应该是seqLen bs hs，所以把第二维进行reorder就行了
  

SeqReader

• 创造了一个embedding层Embed和一个lstm层RNNModule，共享参数是这么实现的，首先我们可以看到模型的大多数参数都在从rnn的out映射到词表这个矩阵上的，所以是否我们可以将这个矩阵用embedding矩阵共享参数，因为rnn_size的大小和embedding size的大小可能不一样，所以我们可以先让rnn_size过一个linear，这个linear的参数会小很多，就是图中的down，共享参数也很简单就是self.out.weight = self.embed.embedding.weight。
  
• self.decode是因为虽然这个只是一个encoder，但是可以根据encoder出来的结果映射成真实的vocab也就是encoder成能懂的句子。
  
• optimizer里面带有要训练的参数，而loss_function就是一个单独的loss_function

loss_function = nn.CrossEntropyLoss(ignore_index=0)
parameters = filter(lambda p: p.requires_grad, model.parameters())
optimizer = optim.Adam(parameters,
                       lr=config["lr"], weight_decay=config["weight_decay"])

trainer

• 这是作者写的一个训练中数据可视化的一个东西，本质上是visdom和matplotlib里面的东西，感觉好像是作者写了一个类似于tensorboard的东西。
  
• trainer里面存放了如何加载数据进行训练，以及现在训练到了什么epoch，第多少step，

best_loss = None
for epoch in range(config["epochs"]):
    train_loss = trainer.train_epoch()
    val_loss = trainer.eval_epoch()

    if config["scheduler"] == "plateau":
        scheduler.step(val_loss)

    elif config["scheduler"] == "cosine":
        scheduler.step()
    elif config["scheduler"] == "step":
        scheduler.step()

    exp.update_metric("lr", optimizer.param_groups[0]['lr'])

    exp.update_metric("ep_loss", train_loss, "TRAIN")
    exp.update_metric("ep_loss", val_loss, "VAL")
    exp.update_metric("ep_ppl", math.exp(train_loss), "TRAIN")
    exp.update_metric("ep_ppl", math.exp(val_loss), "VAL")

    print()
    epoch_log = exp.log_metrics(["ep_loss", "ep_ppl"])
    print(epoch_log)
    exp.update_value("epoch", epoch_log)

    # Save the model if the validation loss is the best we've seen so far.
    if not best_loss or val_loss < best_loss:
        best_loss = val_loss
        trainer.checkpoint()

    print("\n" * 2)

    exp.save()

• trainer 需要做的事情，如果是重启的话要复原trainer中的epoch和step，然后train_epoch和eval_epoch进行训练和测试返回的是各自的loss。
  

• 先看一下Trainer需要的传入参数，值的注意的是每个epoch训练完有一个后处理的函数，用于记录是否到了log的epoch了，如果是的那么就进行记录，这个后处理函数的接口是封装好的，就是trainer的几个数据。
  

• 封装的非常好，我们只需要实现一个如何计算loss的，以及当前有什么状态的即可

class LMTrainer(Trainer):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def _seq_loss(self, predictions, labels):
        _labels = labels.contiguous().view(-1)

        _logits = predictions[0]
        _logits = _logits.contiguous().view(-1, _logits.size(-1))
        loss = self.criterion(_logits, _labels)

        return loss

    def _process_batch(self, inputs, labels, lengths):
        predictions = self.model(inputs, None, lengths)

        loss = self._seq_loss(predictions, labels)
        del predictions
        predictions = None

        return loss, predictions

    def get_state(self):
        if self.train_loader.dataset.subword:
            _vocab = self.train_loader.dataset.subword_path
        else:
            _vocab = self.train_loader.dataset.vocab

        state = {
            "config": self.config,
            "epoch": self.epoch,
            "step": self.step,
            "model": self.model.state_dict(),
            "model_class": self.model.__class__.__name__,
            "optimizers": [x.state_dict() for x in self.optimizers],
            "vocab": _vocab,
        }

        return state

• _process_batch，就是根据训练数据计算得到loss，这个函数无论是训练和测试的时候都可以用，除过loss第二个prediction是被传入batch_end_callbacks中的output，其他的地方没有用了。
  
• get_state是要被写入checkpoint中的东西，其中将config也写进去了。
  
• 至此sent_lm的部分算是完成了，接下来是seq3部分

seq3

• 加载LM模型
  

AEDataset

• 主要还是重构__getitem__这个函数，然后加载数据的在BaseLMDataset上已经有了read_corpus，然后self.data中就是存放的训练数据。
  
• 在collate_fn里面转换成longtensor以及进行pad，这里不用排序，在RNN里面的forward的时候才进行排序，这里的pad_sequence是来自from torch.nn.utils.rnn import pad_sequence，按照这个batch中最大的进行填充，填充的value默认是0，但是注意要设置成batch_first。
  
• 继承的这个seqCollate是自己写的，使用__call__先解包然后调用_collate。
  

Model for seq3

• SeqReader是一个encoder，如果要训练lm设置这里的decode为True，否则的话就是一个纯的encoder
  

• 设置batch_first的地方有两个一个是pad_sequence的时候，一个是LSTM的时候
  
• decoder就是创建一个LSTM和一个Attention，
  
• decoder中的get_embedding，除过step=0的时候一般得到的是sos的embedding ，其他时候可以选择使用gumbel_softmax得到一个embedding
  
• 有一个很奇怪的东西就是为啥要学出一个_init_input_feed
  
• 为啥要给这里加这么多的信息，如果ho是上次的decoder的output信息那么然后这里和decoder出来的生成的emebdding结合起来感觉仍然是很合理的，因此生成embedding的过程中使用了argmax相当于是信息的损失，这里把损失的信息进行了补充。
  
• 这里的attention是这么做的，感觉非常的合理，而且decoder的时候是一个step一个step做的。我们可以看到ho就是decoder的输出加上context信息。
  

• 控制长度这一块还看不懂。
• 温度decoder的时候，embedding的获取方式可以是teacher forcing，可以是gready search 也可以是根据gamble_softmax加权的取出来。
  
• softplus是平滑一点的relu，学习温度，首先是decoder出来的结果先过一个linear（没有bias）映射到一个数字，然后过一个softplus的激活函数然后加上原始的温度，然后被1除就是学习到的当前的温度
  
  
  
• 连接以后作为decoder的返回
  
• topic_idf的embedding size是1，requires_grad为False，
  
• embedding进行初始化
  
• seq3中生成句子。
  
• decoder需要gold_tokens,而作者的是无监督的方法是没有正确答案的，因此制造了一个inp_fake为了在decoder里面可以得到batchsize和max_length。
  
• length_countdown

def length_countdown(lengths):
    batch_size = lengths.size(0)
    max_length = max(lengths)
    desired_lengths = lengths - 1

    _range = torch.arange(0, -max_length, -1, device=lengths.device)
    _range = _range.repeat(batch_size, 1)
    _countdown = _range + desired_lengths.unsqueeze(-1)

    return _countdown

lengths = torch.LongTensor([1,2,3])
print(length_countdown(lengths))
---------------------------------------输出------------------------------------------
tensor([[ 0, -1, -2],
        [ 1,  0, -1],
        [ 2,  1,  0]])

• 但是这个countdown也不是硬性截断的，而是乘了一个可学习的参数w_tick
  
• tick这个生成的是[[1, 0.3], [-1, 0.5]]这种形式的前一个数字是距离结束还可以生成多少个单词1表示还可以生成1个单词，-1表示还可以生成-1个单词（表示多生成了-1个单词）0.3, 0.5是压缩后的句子应该是原始句子的长度。
  
• 用cmp_lengths代表长度是否说明，直接是截断的最大长度？？其实并不是截断的最大长度，因为后面还有一个length loss，lengthu是pack_padded_sequence再用但是encoder的时候是可以得到真实的句子长度的啊，感觉是下面的没有写好，应该根据dec1_results得到真实的length，而不是用latent_lengths - 1得到。
  

• decoder的输出，有单词的概率分布，然后使用这个概率分布进行反向传递，当做是encode的输入单词的embedding。
• 然后使用相当于压缩后的句子进行encoder得到的中间表示再去
  
• bridge就是对encoder的hidden state进行一些线性和非线性的变换到decoder可以用到的hidden state 的维度然后当做hidden state的初始化。
  

train seq3.py

• 映射矩阵从预训练的词向量中进行初始化。

• 将unk和预训练词表中没有的词的gradient mask掉，训练的时候不训练。，这个操作也太强了，why?，是通过weight的register_hook来实现的。
  

• 通过sklearn计算tf idf，tf.idf_，但是要对PAD这个token进行neutralize就是设置为1，让pad不要影响计算。
  

• 让所有的embedding层是一个，十分简单，因为前面只初始化了一个inp_encoder，所以只用embed指向其他的即可。
  

• 共享参数，不使用同一个decoder但是不同decoder的映射词表的矩阵是一样的。

• 打印参数信息，注意之所以能够print model是因为实现了__str__方法。

• 添加一些可以可视化的东西。

trainer seq3

topic loss

• _topic_loss，dec1[3]的decoder的第三个输出，是decoder每个词的概率。
  
• 用每个词的idf进行训练，
  
• 计算方式是emb乘以normal后的tf-idf值，然后按照最后一个维度相加，得到的一个embedding维度的数值进行运算，其实光average一个embedding得到的也是很合理的就是为了让平均的embedding尽可能的相似。
  
• 但是蛋疼的一点就是只对source端做tf-idf，不知道为啥对sourse端没有做，直接注释掉了。
  

lm loss

• 很简单就是算一个之前的decoder结果的logits和现在的logits算一下kl散度即可
  

_process_batch

• 首先得到模型的输出，然后利用输出计算loss
  

• 计算重建损失。

• 然后是上面两种计算LM loss和topic Loss，在这里可以看到其实是吧tf-idf当成了attention的权重对于embedding进行加权。
  

• 还有一个句子长度的loss，所以说生成的compress的时候生成的句子长度不是强行确定就是那么长的，而是使用了loss来限制的，mask，当eos位置一致的时候loss是最小的，此时eos前面的部分eos_labels是0，eos后面的部分_logits是0，所以只有多出来的部分才算loss，
  

• generator生成，感觉这一块是不是有问题啊，gumbel_softmax采样的概率虽然是根据logit采样的，但是慢了一步，为何不用统一使用embedding呢

• logit是decoder生成的词表的logit，dists是从gumbel_softmax中根据上一步的logit和温度采样出来的一个概率分布，然后此时的embedding也是根据这个概率分布得到的。

• _process_batch返回值有两个一个是loss，此处是一个列表，还可以是一个单独的值，第二个batch_outputs就是一些像打印出来的信息。
  

• eval_epoch重写了基础类中的eval_epoch。
  

• 而重写的eval_epoch直接是生成了句子，并没有计算loss，有原因可能是并不容易过拟合，所以只用人来看一下生成的句子是否合理。

• 之前先把model的device给trainer，然后训练和测试的时候再把此时的batch给to(device)，这样做为了省显存。

batch = list(map(lambda x: x.to(self.device), batch))

• train_epoch和test_epoch是在seq3.py中调用的，而train和eval中调用这这个用于根据把batch 计算loss的函数，这里得到的loss是原始的loss，可以在train_epoch进行梯度裁剪更新参数等其他动作。
  
• 原来重写eval_epoch不计算loss的原因是要使用rouge作为评测标准而不是valid上面的loss。
• 重新看一下trainer，里面可以传入一个loss_weight
  
• 每次执行完一个train_epoch的时候就会挨个执行batch_end_callbacks里面的函数。
  

关于前项正常的sample，后项使用概率近似的进行可微的反向传递

• 实现起来很简单，就是计算loss的时候用的不是真实的采样出来的单词，而是用dec2_logits。
  
• topic loss这个时候也一样，就是前项的时候根据gambel_softmax的概率取得最大的概率的单词，然后过LM得到logits_oracle，计算loss的时候却是用原始的logits_dec1，计算的，所以说神经网络在训练的时候前项干了什么并不重要，重要的是怎么更新后项，一般的是用前项的直接结果计算，另一种